Use Module field of DXILOpBuilder to find target SM version and Shader

Kind in createDXILOpCall() instead of computing them in its callers and
passing them as arguments.

Author: bharadwajy

llvm/lib/Target/DirectX/DXIL.td

@@ -237,6 +237,10 @@ def mesh : ShaderStage;
 def node : ShaderStage;
 def raygeneration : ShaderStage;
 def intersection : ShaderStage;
+def anyhit : ShaderStage;
+def closesthit : ShaderStage;
+def callable : ShaderStage;
+def miss : ShaderStage;
 
 // Primitive predicate
 class Pred;

llvm/lib/Target/DirectX/DXILOpBuilder.cpp

@@ -15,6 +15,7 @@
 #include "llvm/IR/Module.h"
 #include "llvm/Support/DXILABI.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/TargetParser/Triple.h"
 
 using namespace llvm;
 using namespace llvm::dxil;
@@ -24,9 +25,7 @@ constexpr StringLiteral DXILOpNamePrefix = "dx.op.";
 // Include DXIL Operation data and corresponding access functions
 // generated by the TableGen backend DXILEmitter.
 #define DXIL_OP_OPERATION_TABLE
-#define SHADER_KIND_ENUM
 #include "DXILOperation.inc"
-#undef SHADER_KIND_ENUM
 #undef DXIL_OP_OPERATION_TABLE
 
 static OverloadKind getOverloadKind(Type *Ty) {
@@ -162,6 +161,45 @@ static Type *getTypeFromParameterKind(ParameterKind Kind, Type *OverloadTy) {
   return nullptr;
 }
 
+static ShaderKind getShaderKindEnum(Triple::EnvironmentType EnvType) {
+  switch (EnvType) {
+  case Triple::Pixel:
+    return ShaderKind::pixel;
+  case Triple::Vertex:
+    return ShaderKind::vertex;
+  case Triple::Geometry:
+    return ShaderKind::geometry;
+  case Triple::Hull:
+    return ShaderKind::hull;
+  case Triple::Domain:
+    return ShaderKind::domain;
+  case Triple::Compute:
+    return ShaderKind::compute;
+  case Triple::Library:
+    return ShaderKind::library;
+  case Triple::RayGeneration:
+    return ShaderKind::raygeneration;
+  case Triple::Intersection:
+    return ShaderKind::intersection;
+  case Triple::AnyHit:
+    return ShaderKind::anyhit;
+  case Triple::ClosestHit:
+    return ShaderKind::closesthit;
+  case Triple::Miss:
+    return ShaderKind::miss;
+  case Triple::Callable:
+    return ShaderKind::callable;
+  case Triple::Mesh:
+    return ShaderKind::mesh;
+  case Triple::Amplification:
+    return ShaderKind::amplification;
+  default:
+    break;
+  }
+  llvm_unreachable(
+      "Shader Kind Not Found - Invalid DXIL Environment Specified");
+}
+
 /// Construct DXIL function type. This is the type of a function with
 /// the following prototype
 ///     OverloadType dx.op.<opclass>.<return-type>(int opcode, <param types>)
@@ -213,11 +251,23 @@ static int getValidConstraintIndex(const OpCodeProperty *Prop,
 namespace llvm {
 namespace dxil {
 
-CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode,
-                                          VersionTuple SMVer,
-                                          StringRef StageKind, Type *ReturnTy,
+CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode, Type *ReturnTy,
                                           Type *OverloadTy,
                                           SmallVector<Value *> Args) {
+
+  std::string TTStr = M.getTargetTriple();
+  // No extra checks need be performed to verify that the Triple is
+  // well-formed or the target is supported since these checks would have
+  // been done at the time the module M is constructed in the earlier stages of
+  // compilation.
+  auto Major = Triple(TTStr).getOSVersion().getMajor();
+  auto MinorOrErr = Triple(TTStr).getOSVersion().getMinor();
+  uint32_t Minor = MinorOrErr.has_value() ? *MinorOrErr : 0;
+  VersionTuple SMVer(Major, Minor);
+  // Get Shader Stage Kind
+  Triple::EnvironmentType ShaderEnv = Triple(TTStr).getEnvironment();
+  auto ShaderEnvStr = Triple(TTStr).getEnvironmentName();
+
   const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
   int Index = getValidConstraintIndex(Prop, SMVer);
   uint16_t ValidTyMask = Prop->Constraints[Index].ValidTys;
@@ -234,10 +284,18 @@ CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode,
         /* gen_crash_diag=*/false);
   }
 
+  // Ensure Environment type is known
+  if (ShaderEnv == Triple::UnknownEnvironment) {
+    report_fatal_error(
+        StringRef(SMVer.getAsString().append(
+            ": Unknown Compilation Target Shader Stage specified ")),
+        /*gen_crash_diag*/ false);
+  }
+
   // Perform necessary checks to ensure Opcode is valid in the targeted shader
   // kind
   uint16_t ValidShaderKindMask = Prop->Constraints[Index].ValidShaderKinds;
-  ShaderKind ModuleStagekind = getShaderkKindEnum(StageKind);
+  enum ShaderKind ModuleStagekind = getShaderKindEnum(ShaderEnv);
 
   // Ensure valid shader stage constraints are specified
   if (ValidShaderKindMask == ShaderKind::Unknown) {
@@ -260,7 +318,7 @@ CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode,
   // Verify the target shader stage is valid for the DXIL operation
   if (!(ValidShaderKindMask & ModuleStagekind)) {
     report_fatal_error(
-        StringRef(std::string(StageKind)
+        StringRef(std::string(ShaderEnvStr)
                       .append(" : Invalid Shader Stage for DXIL operation - ")
                       .append(getOpCodeName(OpCode))
                       .append(" for Shader Model ")
@@ -282,8 +340,17 @@ CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode,
   return B.CreateCall(DXILFn, Args);
 }
 
-Type *DXILOpBuilder::getOverloadType(dxil::OpCode OpCode, VersionTuple SMVer,
-                                     FunctionType *FT) {
+Type *DXILOpBuilder::getOverloadType(dxil::OpCode OpCode, FunctionType *FT) {
+
+  std::string TTStr = M.getTargetTriple();
+  // No extra checks need be performed to verify that the Triple is
+  // well-formed or the target is supported since these checks would have
+  // been done at the time the module M is constructed in the earlier stages of
+  // compilation.
+  auto Major = Triple(TTStr).getOSVersion().getMajor();
+  auto MinorOrErr = Triple(TTStr).getOSVersion().getMinor();
+  uint32_t Minor = MinorOrErr.has_value() ? *MinorOrErr : 0;
+  VersionTuple SMVer(Major, Minor);
 
   const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
   // If DXIL Op has no overload parameter, just return the

llvm/lib/Target/DirectX/DXILOpBuilder.h

@@ -40,12 +40,10 @@ class DXILOpBuilder {
   /// \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,
-                             StringRef StageKind, Type *ReturnTy,
+  CallInst *createDXILOpCall(dxil::OpCode OpCode, Type *ReturnTy,
                              Type *OverloadTy, SmallVector<Value *> Args);
 
-  Type *getOverloadType(dxil::OpCode OpCode, VersionTuple SMVer,
-                        FunctionType *FT);
+  Type *getOverloadType(dxil::OpCode OpCode, FunctionType *FT);
   static const char *getOpCodeName(dxil::OpCode DXILOp);
 
 private:

llvm/lib/Target/DirectX/DXILOpLowering.cpp

@@ -74,11 +74,10 @@ static SmallVector<Value *> argVectorFlatten(CallInst *Orig,
   return NewOperands;
 }
 
-static void lowerIntrinsic(dxil::OpCode DXILOp, Function &F, Module &M,
-                           VersionTuple SMVer, StringRef StageKind) {
+static void lowerIntrinsic(dxil::OpCode DXILOp, Function &F, Module &M) {
   IRBuilder<> B(M.getContext());
   DXILOpBuilder DXILB(M, B);
-  Type *OverloadTy = DXILB.getOverloadType(DXILOp, SMVer, F.getFunctionType());
+  Type *OverloadTy = DXILB.getOverloadType(DXILOp, F.getFunctionType());
   for (User *U : make_early_inc_range(F.users())) {
     CallInst *CI = dyn_cast<CallInst>(U);
     if (!CI)
@@ -94,8 +93,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, StageKind, F.getReturnType(), OverloadTy, Args);
+    CallInst *DXILCI =
+        DXILB.createDXILOpCall(DXILOp, F.getReturnType(), OverloadTy, Args);
 
     CI->replaceAllUsesWith(DXILCI);
     CI->eraseFromParent();
@@ -111,19 +110,6 @@ static bool lowerIntrinsics(Module &M) {
 #include "DXILOperation.inc"
 #undef DXIL_OP_INTRINSIC_MAP
 
-  // Get Shader Model version
-  std::string TTStr = M.getTargetTriple();
-  // No extra checks need be performed to verify that the Triple is
-  // well-formed or the target is supported since these checks would have
-  // been done at the time the module M is constructed in the earlier stages of
-  // compilation.
-  auto Major = Triple(TTStr).getOSVersion().getMajor();
-  auto MinorOrErr = Triple(TTStr).getOSVersion().getMinor();
-  uint32_t Minor = MinorOrErr.has_value() ? *MinorOrErr : 0;
-  VersionTuple SMVer(Major, Minor);
-  // Get Shader Kind
-  std::string StageKind = Triple(TTStr).getEnvironmentName().str();
-
   for (Function &F : make_early_inc_range(M.functions())) {
     if (!F.isDeclaration())
       continue;
@@ -133,7 +119,7 @@ static bool lowerIntrinsics(Module &M) {
     auto LowerIt = LowerMap.find(ID);
     if (LowerIt == LowerMap.end())
       continue;
-    lowerIntrinsic(LowerIt->second, F, M, SMVer, StageKind);
+    lowerIntrinsic(LowerIt->second, F, M);
     Updated = true;
   }
   return Updated;

llvm/test/CodeGen/DirectX/sin_no_stage_error.ll

@@ -1,7 +1,7 @@
 ; RUN: not opt -S -dxil-op-lower -mtriple=dxil-pc-shadermodel6.0 %s 2>&1 | FileCheck %s
 
 ; Shader Stage is required to ensure the operation is supported.
-; CHECK: LLVM ERROR: 6.0: DXIL Module created with Unspecifed or Unknown Target Shader Stage
+; CHECK: LLVM ERROR: 6.0: Unknown Compilation Target Shader Stage specified
 
 define noundef float @sin_float(float noundef %a) #0 {
 entry: