Incorporate PR review feedback

 - Use VersionTriple to deal with Shader Model version.
 - Undo sin test reorganization.

Author: bharadwajy

llvm/include/llvm/Support/DXILABI.h

@@ -90,9 +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)
+struct DXILShaderModel {
+  unsigned Major = 0;
+  unsigned Minor = 0;
+};
 
 #endif // LLVM_SUPPORT_DXILABI_H

llvm/lib/Target/DirectX/DXIL.td

@@ -22,14 +22,10 @@ class DXILShaderModel<int major, int minor> {
 
 // Valid minimum Shader model version records
 
-// Shader Mode 6.x
-foreach i = 0...9 in {
+// Shader Model 6.0 - 6.8
+foreach i = 0...8 in {
   def SM6_#i : DXILShaderModel<6, i>;
 }
-// Shader Model 7.x - for now 7.0 is defined. Extend as needed
-foreach i = 0 in {
-  def SM7_#i : DXILShaderModel<7, i>;
-}
 
 // Abstraction of class mapping valid DXIL Op overloads the minimum
 // version of Shader Model they are supported
@@ -109,14 +105,13 @@ let OpClass = isSpecialFloat in {
                            "Determines if the specified value is infinite.">;
 }
 
-// Unary Class
 let OpClass = unary in {
   def Abs : DXILOpMapping<6, int_fabs, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty, llvm_double_ty]>],
                           "Returns the absolute value of the input.">;
 
   def Cos  : DXILOpMapping<12, int_cos, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
                           "Returns cosine(theta) for theta in radians.">;
-  def Sin  : DXILOpMapping<13, int_sin, [DXILOpOverload<SM6_3, [llvm_half_ty, llvm_float_ty]>,
+  def Sin  : DXILOpMapping<13, int_sin, [DXILOpOverload<SM6_2, [llvm_half_ty, llvm_float_ty]>,
                                          DXILOpOverload<SM6_0, [llvm_float_ty]>],
                            "Returns sine(theta) for theta in radians.">;
   def Exp2 : DXILOpMapping<21, int_exp2, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
@@ -146,7 +141,6 @@ let OpClass = unary in {
                             "Returns the specified value with its bits reversed.">;
 }
 
-// Binary Class
 let OpClass = binary in {
 // Float overloads
   def FMax : DXILOpMapping<35, int_maxnum, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty, llvm_double_ty]>],
@@ -164,10 +158,7 @@ let OpClass = binary in {
                            "Unsigned integer minimum. UMin(a,b) = a < b ? a : b">;
 }
 
-// Tertiary Class
 let OpClass = tertiary in {
-// Float overloads
-//   let OpOverloadTypes =  [llvm_half_ty, llvm_float_ty, llvm_double_ty] in {
   def FMad : DXILOpMapping<46, int_fmuladd, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty, llvm_double_ty]>],
                             "Floating point arithmetic multiply/add operation."
                             " fmad(m,a,b) = m * a + b.">;
@@ -181,7 +172,6 @@ def UMad : DXILOpMapping<49, int_dx_umad, [DXILOpOverload<SM6_0, [llvm_i16_ty, l
 }
 
 // Dot Operations
-// let OpOverloadTypes =  [llvm_half_ty, llvm_float_ty] in
 let OpClass = dot2 in
   def Dot2 : DXILOpMapping<54, int_dx_dot2, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
                           "dot product of two float vectors Dot(a,b) = a[0]*b[0] +"

llvm/lib/Target/DirectX/DXILOpBuilder.cpp

@@ -15,6 +15,9 @@
 #include "llvm/IR/Module.h"
 #include "llvm/Support/DXILABI.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/VersionTuple.h"
+#include <algorithm>
+#include <cassert>
 #include <string>
 
 using namespace llvm;
@@ -125,7 +128,7 @@ static std::string getTypeName(OverloadKind Kind, Type *Ty) {
 }
 
 struct OpSMOverloadProp {
-  uint16_t ShaderModelVer;
+  DXILShaderModel ShaderModelVer;
   uint16_t ValidTys;
 };
 
@@ -256,35 +259,35 @@ static FunctionType *getDXILOpFunctionType(const OpCodeProperty *Prop,
 }
 
 static uint16_t getValidOverloadMask(const OpCodeProperty *Prop,
-                                     uint32_t SMVer) {
+                                     VersionTuple SMVer) {
   uint16_t ValidTyMask = 0;
   // std::vector Prop->OverloadProp is in ascending order of SM Version
   // Overloads of highest SM version that is not greater than SMVer
   // are the ones that are valid for SMVer.
-  for (auto OL : Prop->OverloadProp) {
-    if (OL.ShaderModelVer <= SMVer) {
-      ValidTyMask = OL.ValidTys;
-    } else {
-      break;
-    }
-  }
+
+  // Get the lower bound value iterator of SMVer
+  auto LaterSM = std::lower_bound(
+      Prop->OverloadProp.begin(), Prop->OverloadProp.end(), SMVer,
+      [](const OpSMOverloadProp OL, VersionTuple VerTup) {
+        return (VersionTuple(OL.ShaderModelVer.Major,
+                             OL.ShaderModelVer.Minor) <= VerTup);
+      });
+  // Valid overloads are of the version prior to the lower bound
+  ValidTyMask = (--LaterSM)->ValidTys;
+  assert(ValidTyMask != 0 && "No valid overload types found");
   return ValidTyMask;
 }
 
 namespace llvm {
 namespace dxil {
 
-CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode, uint32_t SMVer,
-                                          Type *ReturnTy, Type *OverloadTy,
+CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode,
+                                          VersionTuple &SMVer, Type *ReturnTy,
+                                          Type *OverloadTy,
                                           SmallVector<Value *> Args) {
   const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
   uint16_t ValidTyMask = getValidOverloadMask(Prop, SMVer);
 
-  if (ValidTyMask == 0) {
-    report_fatal_error(StringRef(std::to_string(SMVer).append(
-                           ": Unhandled Shader Model Version")),
-                       /*gen_crash_diag*/ false);
-  }
   OverloadKind Kind = getOverloadKind(OverloadTy);
   if ((ValidTyMask & (uint16_t)Kind) == 0) {
     report_fatal_error("Invalid Overload Type", /* gen_crash_diag=*/false);
@@ -304,7 +307,7 @@ CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode, uint32_t SMVer,
   return B.CreateCall(DXILFn, Args);
 }
 
-Type *DXILOpBuilder::getOverloadTy(dxil::OpCode OpCode, uint32_t SMVer,
+Type *DXILOpBuilder::getOverloadTy(dxil::OpCode OpCode, VersionTuple &SMVer,
                                    FunctionType *FT) {
 
   const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
@@ -313,11 +316,6 @@ Type *DXILOpBuilder::getOverloadTy(dxil::OpCode OpCode, uint32_t SMVer,
   if (Prop->OverloadParamIndex < 0) {
     auto &Ctx = FT->getContext();
     uint16_t ValidTyMask = getValidOverloadMask(Prop, SMVer);
-    if (ValidTyMask == 0) {
-      report_fatal_error(StringRef(std::to_string(SMVer).append(
-                             ": Unhandled Shader Model Version")),
-                         /*gen_crash_diag*/ false);
-    }
 
     switch (ValidTyMask) {
     case OverloadKind::VOID:
@@ -344,14 +342,15 @@ Type *DXILOpBuilder::getOverloadTy(dxil::OpCode OpCode, uint32_t SMVer,
     }
   }
 
-  // Prop->OverloadParamIndex is 0, overload type is FT->getReturnType().
+  // Consider FT->getReturnType() as default overload type, unless
+  // Prop->OverloadParamIndex != 0.
   Type *OverloadType = FT->getReturnType();
   if (Prop->OverloadParamIndex != 0) {
     // Skip Return Type.
     OverloadType = FT->getParamType(Prop->OverloadParamIndex - 1);
   }
 
-  auto ParamKinds = getOpCodeParameterKind(*Prop);
+  const auto *ParamKinds = getOpCodeParameterKind(*Prop);
   auto Kind = ParamKinds[Prop->OverloadParamIndex];
   // For ResRet and CBufferRet, OverloadTy is in field of StructType.
   if (Kind == ParameterKind::CBufferRet ||

llvm/lib/Target/DirectX/DXILOpBuilder.h

@@ -14,7 +14,7 @@
 
 #include "DXILConstants.h"
 #include "llvm/ADT/SmallVector.h"
-#include <cstdint>
+#include "llvm/Support/VersionTuple.h"
 
 namespace llvm {
 class Module;
@@ -38,10 +38,11 @@ class DXILOpBuilder {
   /// \param ReturnTy Return type of the DXIL Op call constructed
   /// \param OverloadTy Overload type of the DXIL Op call constructed
   /// \return DXIL Op call constructed
-  CallInst *createDXILOpCall(dxil::OpCode OpCode, uint32_t SMVer,
+  CallInst *createDXILOpCall(dxil::OpCode OpCode, VersionTuple &SMVer,
                              Type *ReturnTy, Type *OverloadTy,
                              SmallVector<Value *> Args);
-  Type *getOverloadTy(dxil::OpCode OpCode, uint32_t SMVer, FunctionType *FT);
+  Type *getOverloadTy(dxil::OpCode OpCode, VersionTuple &SMVer,
+                      FunctionType *FT);
   static const char *getOpCodeName(dxil::OpCode DXILOp);
 
 private:

llvm/lib/Target/DirectX/DXILOpLowering.cpp

@@ -25,6 +25,7 @@
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/VersionTuple.h"
 
 #define DEBUG_TYPE "dxil-op-lower"
 
@@ -73,7 +74,7 @@ static SmallVector<Value *> argVectorFlatten(CallInst *Orig,
   return NewOperands;
 }
 
-static uint32_t getModuleShaderModelVersion(Module &M) {
+static VersionTuple getModuleShaderModelVersion(Module &M) {
   std::string TTStr = M.getTargetTriple();
   std::string Error;
   auto Target = TargetRegistry::lookupTarget(TTStr, Error);
@@ -82,16 +83,13 @@ static uint32_t getModuleShaderModelVersion(Module &M) {
       report_fatal_error(StringRef(Error), /*gen_crash_diag*/ false);
     }
   }
-  auto Major = Triple(TTStr).getOSVersion().getMajor();
-  auto MinorOrErr = Triple(TTStr).getOSVersion().getMinor();
-  uint32_t Minor = MinorOrErr.has_value() ? *MinorOrErr : 0;
-  return COMPUTE_SM_VERSION_VALUE(Major, Minor);
+  return Triple(TTStr).getOSVersion();
 }
 
 static void lowerIntrinsic(dxil::OpCode DXILOp, Function &F, Module &M) {
   IRBuilder<> B(M.getContext());
   DXILOpBuilder DXILB(M, B);
-  uint32_t SMVer = getModuleShaderModelVersion(M);
+  VersionTuple 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/test/CodeGen/DirectX/Inputs/sin/double.ll

@@ -0,0 +1,16 @@
+; RUN: not opt -S -dxil-op-lower -mtriple=dxil-pc-shadermodel6.0-library %s 2>&1 | FileCheck %s --check-prefix=SM6_0_DOUBLE
+; RUN: not opt -S -dxil-op-lower -mtriple=dxil-pc-shadermodel6.3-library %s 2>&1 | FileCheck %s --check-prefix=SM6_3_DOUBLE
+
+; Double is not valid in any Shader Model version
+; SM6_0_DOUBLE: LLVM ERROR: Invalid Overload
+; SM6_3_DOUBLE: LLVM ERROR: Invalid Overload
+
+define noundef double @sin_double(double noundef %a) #0 {
+entry:
+  %a.addr = alloca double, align 8
+  store double %a, ptr %a.addr, align 8
+  %0 = load double, ptr %a.addr, align 8
+  %1 = call double @llvm.sin.f64(double %0)
+  ret double %1
+}
+

llvm/test/CodeGen/DirectX/sin.ll

@@ -1,3 +1,8 @@
+; RUN: opt -S -dxil-op-lower -mtriple=dxil-pc-shadermodel6.0-library %s | FileCheck %s -check-prefix=SM6_0_FLOAT
+
+; Float is valid for SM6.0
+; SM6_0_FLOAT: call float @dx.op.unary.f32(i32 13, float %{{.*}})
+
 ; Function Attrs: noinline nounwind optnone
 define noundef float @sin_float(float noundef %a) #0 {
 entry:

llvm/test/CodeGen/DirectX/sin_error.ll

@@ -1,3 +1,8 @@
+; RUN: not opt -S -dxil-op-lower -mtriple=dxil-pc-shadermodel6.0-library %s 2>&1 | FileCheck %s -check-prefix=SM6_0_HALF
+
+; Half is not valid for SM6.0
+; SM6_0_HALF: LLVM ERROR: Invalid Overload
+
 ; Function Attrs: noinline nounwind optnone
 define noundef half @sin_half(half noundef %a) #0 {
 entry:

llvm/test/CodeGen/DirectX/Inputs/sin/float.ll renamed to llvm/test/CodeGen/DirectX/sin_sm_60.ll

@@ -0,0 +1,25 @@
+; RUN: opt -S -dxil-op-lower -mtriple=dxil-pc-shadermodel6.3-library %s | FileCheck %s -check-prefix=SM6_3
+; Half and float are valid for SM6.2 and later
+; SM6_3: call half @dx.op.unary.f16(i32 13, half %{{.*}})
+; SM6_3: call float @dx.op.unary.f32(i32 13, float %{{.*}})
+
+; Function Attrs: noinline nounwind optnone
+define noundef half @sin_half(half noundef %a) #0 {
+entry:
+  %a.addr = alloca half, align 2
+  store half %a, ptr %a.addr, align 2
+  %0 = load half, ptr %a.addr, align 2
+  %1 = call half @llvm.sin.f16(half %0)
+  ret half %1
+}
+
+; Function Attrs: noinline nounwind optnone
+define noundef float @sin_float(float noundef %a) #0 {
+entry:
+  %a.addr = alloca float, align 4
+  store float %a, ptr %a.addr, align 4
+  %0 = load float, ptr %a.addr, align 4
+  %1 = call float @llvm.sin.f32(float %0)
+  ret float %1
+}
+

llvm/test/CodeGen/DirectX/Inputs/sin/half.ll renamed to llvm/test/CodeGen/DirectX/sin_sm_60_error.ll

@@ -0,0 +1,16 @@
+; RUN: not opt -S -dxil-op-lower -mtriple=dxil-pc-shadermodel6.0-library %s 2>&1 | FileCheck %s --check-prefix=SM6_0_DOUBLE
+; RUN: not opt -S -dxil-op-lower -mtriple=dxil-pc-shadermodel6.3-library %s 2>&1 | FileCheck %s --check-prefix=SM6_3_DOUBLE
+
+; Double is not valid in any Shader Model version
+; SM6_0_DOUBLE: LLVM ERROR: Invalid Overload
+; SM6_3_DOUBLE: LLVM ERROR: Invalid Overload
+
+define noundef double @sin_double(double noundef %a) #0 {
+entry:
+  %a.addr = alloca double, align 8
+  store double %a, ptr %a.addr, align 8
+  %0 = load double, ptr %a.addr, align 8
+  %1 = call double @llvm.sin.f64(double %0)
+  ret double %1
+}
+