Delete Shader Model version based overload type specification.

bharadwajy · bharadwajy · commit 560d94f8d5ee · 2024-05-29T22:56:28.000Z
diff --git a/llvm/include/llvm/Support/DXILABI.h b/llvm/include/llvm/Support/DXILABI.h
@@ -90,9 +90,4 @@ enum class ElementType : uint32_t {
 } // namespace dxil
 } // namespace llvm
 
-struct DXILShaderModel {
-  unsigned Major = 0;
-  unsigned Minor = 0;
-};
-
 #endif // LLVM_SUPPORT_DXILABI_H
diff --git a/llvm/lib/Target/DirectX/DXIL.td b/llvm/lib/Target/DirectX/DXIL.td
@@ -13,26 +13,6 @@
 
 include "llvm/IR/Intrinsics.td"
 
-// Abstract class to represent major and minor version values
-class Version<int major, int minor> {
-  int Major = major;
-  int Minor = minor;
-}
-
-// Valid minimum Shader model version records
-
-// Shader Model 6.0 - 6.8
-foreach i = 0...8 in {
-  def SM6_#i : Version<6, i>;
-}
-
-// Abstraction of class mapping valid DXIL Op overloads the minimum
-// version of Shader Model they are supported
-class DXILOpOverload<Version minsm, list<LLVMType> overloads> {
-  Version ShaderModel = minsm;
-  list<LLVMType> OpOverloads = overloads;
-}
-
 // Abstraction of DXIL Operation class.
 // It encapsulates an associated function signature viz.,
 // returnTy(param1Ty, param2Ty, ...) represented as a list of LLVMTypes.
@@ -44,10 +24,9 @@ class DXILOpClass<list<LLVMType> OpSig> {
 }
 
 // Concrete definitions of DXIL Op Classes
-// Note that these class name strings are specified as the third argument
-// of add_dixil_op in utils/hct/hctdb.py and case converted in
-// utils/hct/hctdb_instrhelp.py of DirectXShaderCompiler repo. The function
-// name has the format "dx.op.<class-name>.<return-type>", in most cases.
+// Refer to the design document
+// (https://github.com/llvm/llvm-project/blob/main/llvm/docs/DirectX/DXILOpTableGenDesign.rst)
+// for details about the use of DXIL Op Class name.
 
 // NOTE: The following list is not complete. Classes need to be defined as new DXIL Ops
 // are added.
@@ -81,123 +60,120 @@ class DXILOpPropertiesBase {
   int OpCode = 0;                      // Opcode of DXIL Operation
   DXILOpClass OpClass = UnknownOpClass;// Class of DXIL Operation.
   Intrinsic LLVMIntrinsic = ?;         // LLVM Intrinsic DXIL Operation maps to
-  list<DXILOpOverload> OpOverloadTypes = ?; // Valid overload type
+  list<LLVMType> OpOverloadTypes = ?; // Valid overload type
                                        // of DXIL Operation
   string Doc = "";                     // A short description of the operation
 }
 
 class DXILOpProperties<int opCode,
                     Intrinsic intrinsic,
-                    list<DXILOpOverload> overloadTypes,
+                    list<LLVMType> overloadTypes,
                     string doc> : DXILOpPropertiesBase {
   int OpCode = opCode;
   Intrinsic LLVMIntrinsic = intrinsic;
-  list<DXILOpOverload> OpOverloadTypes = overloadTypes;
+  list<LLVMType> OpOverloadTypes = overloadTypes;
   string Doc = doc;
 }
 
 // Concrete definitions of DXIL Operation Properties to corresponding LLVM intrinsic
 
 // IsSpecialFloat Class
 let OpClass = isSpecialFloat in {
-  def IsInf : DXILOpProperties<9,  int_dx_isinf, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def IsInf : DXILOpProperties<9,  int_dx_isinf, [llvm_half_ty, llvm_float_ty],
                            "Determines if the specified value is infinite.">;
 }
 
 let OpClass = unary in {
-  def Abs : DXILOpProperties<6, int_fabs, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty, llvm_double_ty]>],
+  def Abs : DXILOpProperties<6, int_fabs, [llvm_half_ty, llvm_float_ty, llvm_double_ty],
                           "Returns the absolute value of the input.">;
 
-  def Cos  : DXILOpProperties<12, int_cos, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Cos  : DXILOpProperties<12, int_cos, [llvm_half_ty, llvm_float_ty],
                           "Returns cosine(theta) for theta in radians.">;
-  def Sin  : DXILOpProperties<13, int_sin, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Sin  : DXILOpProperties<13, int_sin, [llvm_half_ty, llvm_float_ty],
                            "Returns sine(theta) for theta in radians.">;
-  def Tan  : DXILOpProperties<14, int_tan, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Tan  : DXILOpProperties<14, int_tan, [llvm_half_ty, llvm_float_ty],
                            "Returns tangent(theta) for theta in radians.">;
-  def Exp2 : DXILOpProperties<21, int_exp2, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Exp2 : DXILOpProperties<21, int_exp2, [llvm_half_ty, llvm_float_ty],
                            "Returns the base 2 exponential, or 2**x, of the"
                            " specified value. exp2(x) = 2**x.">;
-  def Frac : DXILOpProperties<22, int_dx_frac, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Frac : DXILOpProperties<22, int_dx_frac, [llvm_half_ty, llvm_float_ty],
                             "Returns a fraction from 0 to 1 that represents the"
                             " decimal part of the input.">;
-  def Log2 : DXILOpProperties<23, int_log2, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Log2 : DXILOpProperties<23, int_log2, [llvm_half_ty, llvm_float_ty],
                            "Returns the base-2 logarithm of the specified value.">;
-  def Sqrt : DXILOpProperties<24, int_sqrt, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Sqrt : DXILOpProperties<24, int_sqrt, [llvm_half_ty, llvm_float_ty],
                            "Returns the square root of the specified floating-point"
                            "value, per component.">;
-  def RSqrt : DXILOpProperties<25, int_dx_rsqrt, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def RSqrt : DXILOpProperties<25, int_dx_rsqrt, [llvm_half_ty, llvm_float_ty],
                             "Returns the reciprocal of the square root of the"
                             " specified value. rsqrt(x) = 1 / sqrt(x).">;
-  def Round : DXILOpProperties<26, int_roundeven, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Round : DXILOpProperties<26, int_roundeven, [llvm_half_ty, llvm_float_ty],
                             "Returns the input rounded to the nearest integer"
                             "within a floating-point type.">;
-  def Floor : DXILOpProperties<27, int_floor, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Floor : DXILOpProperties<27, int_floor, [llvm_half_ty, llvm_float_ty],
                             "Returns the largest integer that is less than or equal to the input.">;
-  def Ceil  : DXILOpProperties<28, int_ceil, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Ceil  : DXILOpProperties<28, int_ceil, [llvm_half_ty, llvm_float_ty],
                             "Returns the smallest integer that is greater than or equal to the input.">;
-  def Trunc : DXILOpProperties<29, int_trunc, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Trunc : DXILOpProperties<29, int_trunc, [llvm_half_ty, llvm_float_ty],
                             "Returns the specified value truncated to the integer component.">;
-  def Rbits : DXILOpProperties<30, int_bitreverse, [DXILOpOverload<SM6_0, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty]>],
+  def Rbits : DXILOpProperties<30, int_bitreverse, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty],
                             "Returns the specified value with its bits reversed.">;
 }
 
 let OpClass = binary in {
 // Float overloads
-  def FMax : DXILOpProperties<35, int_maxnum, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty, llvm_double_ty]>],
+  def FMax : DXILOpProperties<35, int_maxnum, [llvm_half_ty, llvm_float_ty, llvm_double_ty],
                            "Float maximum. FMax(a,b) = a > b ? a : b">;
-  def FMin : DXILOpProperties<36, int_minnum, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty, llvm_double_ty]>],
+  def FMin : DXILOpProperties<36, int_minnum, [llvm_half_ty, llvm_float_ty, llvm_double_ty],
                            "Float minimum. FMin(a,b) = a < b ? a : b">;
 // Int overloads
-  def SMax : DXILOpProperties<37, int_smax, [DXILOpOverload<SM6_0,[llvm_i16_ty, llvm_i32_ty, llvm_i64_ty]>],
+  def SMax : DXILOpProperties<37, int_smax, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty],
                            "Signed integer maximum. SMax(a,b) = a > b ? a : b">;
-  def SMin : DXILOpProperties<38, int_smin, [DXILOpOverload<SM6_0,[llvm_i16_ty, llvm_i32_ty, llvm_i64_ty]>],
+  def SMin : DXILOpProperties<38, int_smin, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty],
                            "Signed integer minimum. SMin(a,b) = a < b ? a : b">;
-  def UMax : DXILOpProperties<39, int_umax, [DXILOpOverload<SM6_0,[llvm_i16_ty, llvm_i32_ty, llvm_i64_ty]>],
+  def UMax : DXILOpProperties<39, int_umax, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty],
                            "Unsigned integer maximum. UMax(a,b) = a > b ? a : b">;
-  def UMin : DXILOpProperties<40, int_umin, [DXILOpOverload<SM6_0,[llvm_i16_ty, llvm_i32_ty, llvm_i64_ty]>],
+  def UMin : DXILOpProperties<40, int_umin, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty],
                            "Unsigned integer minimum. UMin(a,b) = a < b ? a : b">;
 }
 
 let OpClass = tertiary in {
-  def FMad : DXILOpProperties<46, int_fmuladd, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty, llvm_double_ty]>],
+  def FMad : DXILOpProperties<46, int_fmuladd, [llvm_half_ty, llvm_float_ty, llvm_double_ty],
                             "Floating point arithmetic multiply/add operation."
                             " fmad(m,a,b) = m * a + b.">;
 // Int overloads
-def IMad : DXILOpProperties<48, int_dx_imad, [DXILOpOverload<SM6_0, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty]>],
+def IMad : DXILOpProperties<48, int_dx_imad, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty],
                          "Signed integer arithmetic multiply/add operation."
                           " imad(m,a,b) = m * a + b.">;
-def UMad : DXILOpProperties<49, int_dx_umad, [DXILOpOverload<SM6_0, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty]>],
+def UMad : DXILOpProperties<49, int_dx_umad, [llvm_i16_ty, llvm_i32_ty, llvm_i64_ty],
                         "Unsigned integer arithmetic multiply/add operation."
                         " umad(m,a, = m * a + b.">;
 }
 
-// Dot Operations
 let OpClass = dot2 in
-  def Dot2 : DXILOpProperties<54, int_dx_dot2, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Dot2 : DXILOpProperties<54, int_dx_dot2, [llvm_half_ty, llvm_float_ty],
                           "dot product of two float vectors Dot(a,b) = a[0]*b[0] +"
                           " ... + a[n]*b[n] where n is between 0 and 1">;
 let OpClass = dot3 in
-  def Dot3 : DXILOpProperties<55, int_dx_dot3, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+  def Dot3 : DXILOpProperties<55, int_dx_dot3, [llvm_half_ty, llvm_float_ty],
                            "dot product of two float vectors Dot(a,b) = a[0]*b[0] +"
                            " ... + a[n]*b[n] where n is between 0 and 2">;
 let OpClass = dot4 in
-   def Dot4 : DXILOpProperties<56, int_dx_dot4, [DXILOpOverload<SM6_0, [llvm_half_ty, llvm_float_ty]>],
+   def Dot4 : DXILOpProperties<56, int_dx_dot4, [llvm_half_ty, llvm_float_ty],
                             "dot product of two float vectors Dot(a,b) = a[0]*b[0] +"
                             " ... + a[n]*b[n] where n is between 0 and 3">;
-
-// Thread Operations
 let OpClass =  threadId in
-  def ThreadId : DXILOpProperties<93, int_dx_thread_id, [DXILOpOverload<SM6_0, [llvm_i32_ty]>],
+  def ThreadId : DXILOpProperties<93, int_dx_thread_id, [llvm_i32_ty],
                               "Reads the thread ID">;
 let OpClass =  groupId in
-  def GroupId  : DXILOpProperties<94, int_dx_group_id, [DXILOpOverload<SM6_0, [llvm_i32_ty]>],
+  def GroupId  : DXILOpProperties<94, int_dx_group_id, [llvm_i32_ty],
                                "Reads the group ID (SV_GroupID)">;
 let OpClass =  threadIdInGroup in
-  def ThreadIdInGroup : DXILOpProperties<95, int_dx_thread_id_in_group, [DXILOpOverload<SM6_0, [llvm_i32_ty]>],
+  def ThreadIdInGroup : DXILOpProperties<95, int_dx_thread_id_in_group, [llvm_i32_ty],
                                      "Reads the thread ID within the group "
                                      "(SV_GroupThreadID)">;
 let OpClass = flattenedThreadIdInGroup in
   def FlattenedThreadIdInGroup : DXILOpProperties<96, int_dx_flattened_thread_id_in_group,
-                                               [DXILOpOverload<SM6_0, [llvm_i32_ty]>],
+                                               [llvm_i32_ty],
                                                 "Provides a flattened index for a given"
                                                 " thread within a given group (SV_GroupIndex)">;
diff --git a/llvm/lib/Target/DirectX/DXILOpBuilder.cpp b/llvm/lib/Target/DirectX/DXILOpBuilder.cpp
@@ -15,10 +15,6 @@
 #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;
 using namespace llvm::dxil;
@@ -127,11 +123,6 @@ static std::string getTypeName(OverloadKind Kind, Type *Ty) {
   }
 }
 
-struct OpSMOverloadProp {
-  DXILShaderModel ShaderModelVer;
-  uint16_t ValidTys;
-};
-
 // Static properties.
 struct OpCodeProperty {
   dxil::OpCode OpCode;
@@ -140,7 +131,7 @@ struct OpCodeProperty {
   dxil::OpCodeClass OpCodeClass;
   // Offset in DXILOpCodeClassNameTable.
   unsigned OpCodeClassNameOffset;
-  std::vector<OpSMOverloadProp> OverloadProp;
+  uint16_t OverloadTys;
   llvm::Attribute::AttrKind FuncAttr;
   int OverloadParamIndex;        // parameter index which control the overload.
                                  // When < 0, should be only 1 overload type.
@@ -258,38 +249,16 @@ static FunctionType *getDXILOpFunctionType(const OpCodeProperty *Prop,
       ArgTys[0], ArrayRef<Type *>(&ArgTys[1], ArgTys.size() - 1), false);
 }
 
-static uint16_t getValidOverloadMask(const OpCodeProperty *Prop,
-                                     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.
-
-  // 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,
-                                          VersionTuple &SMVer, Type *ReturnTy,
+CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode, Type *ReturnTy,
                                           Type *OverloadTy,
                                           SmallVector<Value *> Args) {
   const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
-  uint16_t ValidTyMask = getValidOverloadMask(Prop, SMVer);
 
   OverloadKind Kind = getOverloadKind(OverloadTy);
-  if ((ValidTyMask & (uint16_t)Kind) == 0) {
+  if ((Prop->OverloadTys & (uint16_t)Kind) == 0) {
     report_fatal_error("Invalid Overload Type", /* gen_crash_diag=*/false);
   }
 
@@ -307,17 +276,14 @@ CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode,
   return B.CreateCall(DXILFn, Args);
 }
 
-Type *DXILOpBuilder::getOverloadTy(dxil::OpCode OpCode, VersionTuple &SMVer,
-                                   FunctionType *FT) {
+Type *DXILOpBuilder::getOverloadTy(dxil::OpCode OpCode, FunctionType *FT) {
 
   const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
   // If DXIL Op has no overload parameter, just return the
   // precise return type specified.
   if (Prop->OverloadParamIndex < 0) {
     auto &Ctx = FT->getContext();
-    uint16_t ValidTyMask = getValidOverloadMask(Prop, SMVer);
-
-    switch (ValidTyMask) {
+    switch (Prop->OverloadTys) {
     case OverloadKind::VOID:
       return Type::getVoidTy(Ctx);
     case OverloadKind::HALF:
diff --git a/llvm/lib/Target/DirectX/DXILOpBuilder.h b/llvm/lib/Target/DirectX/DXILOpBuilder.h
@@ -14,7 +14,6 @@
 
 #include "DXILConstants.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/VersionTuple.h"
 
 namespace llvm {
 class Module;
@@ -34,15 +33,13 @@ class DXILOpBuilder {
   /// opcode, and call arguments.
   ///
   /// \param OpCode Opcode of the DXIL Op call constructed
-  /// \param SMVer Shader Model Version of DXIL Op call to construct
   /// \param ReturnTy Return type of the DXIL Op call constructed
   /// \param OverloadTy Overload type of the DXIL Op call constructed
+  /// \param Args Arguments for the DXIL Op call constructed
   /// \return DXIL Op call constructed
-  CallInst *createDXILOpCall(dxil::OpCode OpCode, VersionTuple &SMVer,
-                             Type *ReturnTy, Type *OverloadTy,
-                             SmallVector<Value *> Args);
-  Type *getOverloadTy(dxil::OpCode OpCode, VersionTuple &SMVer,
-                      FunctionType *FT);
+  CallInst *createDXILOpCall(dxil::OpCode OpCode, Type *ReturnTy,
+                             Type *OverloadTy, SmallVector<Value *> Args);
+  Type *getOverloadTy(dxil::OpCode OpCode, FunctionType *FT);
   static const char *getOpCodeName(dxil::OpCode DXILOp);
 
 private:
diff --git a/llvm/lib/Target/DirectX/DXILOpLowering.cpp b/llvm/lib/Target/DirectX/DXILOpLowering.cpp
@@ -22,10 +22,8 @@
 #include "llvm/IR/IntrinsicsDirectX.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
-#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"
 
@@ -74,23 +72,10 @@ static SmallVector<Value *> argVectorFlatten(CallInst *Orig,
   return NewOperands;
 }
 
-static VersionTuple getModuleShaderModelVersion(Module &M) {
-  std::string TTStr = M.getTargetTriple();
-  std::string Error;
-  auto Target = TargetRegistry::lookupTarget(TTStr, Error);
-  if (!Target) {
-    if (TTStr.empty()) {
-      report_fatal_error(StringRef(Error), /*gen_crash_diag*/ false);
-    }
-  }
-  return Triple(TTStr).getOSVersion();
-}
-
 static void lowerIntrinsic(dxil::OpCode DXILOp, Function &F, Module &M) {
   IRBuilder<> B(M.getContext());
   DXILOpBuilder DXILB(M, B);
-  VersionTuple SMVer = getModuleShaderModelVersion(M);
-  Type *OverloadTy = DXILB.getOverloadTy(DXILOp, SMVer, F.getFunctionType());
+  Type *OverloadTy = DXILB.getOverloadTy(DXILOp, F.getFunctionType());
   for (User *U : make_early_inc_range(F.users())) {
     CallInst *CI = dyn_cast<CallInst>(U);
     if (!CI)
@@ -106,8 +91,8 @@ static void lowerIntrinsic(dxil::OpCode DXILOp, Function &F, Module &M) {
     } else
       Args.append(CI->arg_begin(), CI->arg_end());
 
-    CallInst *DXILCI = DXILB.createDXILOpCall(DXILOp, SMVer, F.getReturnType(),
-                                              OverloadTy, Args);
+    CallInst *DXILCI =
+        DXILB.createDXILOpCall(DXILOp, F.getReturnType(), OverloadTy, Args);
 
     CI->replaceAllUsesWith(DXILCI);
     CI->eraseFromParent();
diff --git a/llvm/utils/TableGen/DXILEmitter.cpp b/llvm/utils/TableGen/DXILEmitter.cpp
