[TableGen][DirectX] Add tableGen backend to generate map from llvm intrinsic to DXIL operation.

[python3kgae]

Summary

A new tableGen backend gen-dxil-intrinsic-map is added to generate map from llvm intrinsic to DXIL operation.

A new file "DXILIntrinsicMap.inc" will be generated when build DirectX target which include the map.

The generated map will replace the manually created map when find DXIL operation from llvm intrinsic.

[nhaehnle]

Running TableGen multiple times is a bit annoying for LLVM build times. Have you considered packing all outputs into the same .inc file?

[python3kgae]

In D125519#3517697, @nhaehnle wrote:

Running TableGen multiple times is a bit annoying for LLVM build times. Have you considered packing all outputs into the same .inc file?

Sure. I'll make all these things into one '.inc` file.
Thanks for the suggestion.

[python3kgae]

Move EmitDXILIntrinsicMap into EmitDXILOperation.

[python3kgae]

Add static for internal function.

[bogner]

llvm/lib/Target/DirectX/DXILOpLowering.cpp

67

Why do this? Since the switch statement covers all values of the enum there are nice warnings (at least if you build with clang) if someone adds another OverloadKind, and forgets to update here, whereas with the default statement that's not the case.

I guess some compilers might warn that not all paths return a value though if they think we can fall out of the switch. If you're just trying to handle that warning then it's probably best to move the llvm_unreachable + return statement out of the switch and just put break here, to get the best of both worlds.

llvm/utils/TableGen/DXILEmitter.cpp

87

Might be worth an assert that the intrinsic name starts with "int_" just in case someone makes a mistake in the td. OTOH I think we'll already error in that case because map_intrinsic won't find anything, so maybe it's fine.

197

Probably better done as a separate change, but is a SmallDenseMap really the best option here? We could probably just store this as an array of pairs and pre-sort it, then query it with std::lower_bound on the keys instead.

[python3kgae]

Update to match the comments.

[python3kgae]

llvm/utils/TableGen/DXILEmitter.cpp

197

Tried to change to array. But find it hard to get intrinsic ID in tableGen for pre-sort.
Leave it for future change.

llvm/lib/Target/DirectX/DXILOpLowering.cpp

case OverloadKind::I16:
     return "i16";
   case OverloadKind::I32:
     return "i32";
   case OverloadKind::I64:
     return "i64";
   case OverloadKind::VOID:
   case OverloadKind::ObjectType:
   case OverloadKind::UserDefineType:
-    llvm_unreachable("invalid overload type for name");
-    return "void";
-  }
-}
+    break;
+  }
 
 static OverloadKind getOverloadKind(Type *Ty) {
   Type::TypeID T = Ty->getTypeID();
   switch (T) {
   case Type::VoidTyID:
     return OverloadKind::VOID;
   case Type::HalfTyID:
     return OverloadKind::HALF;
for (User *U : make_early_inc_range(F.users())) {
     CI->eraseFromParent();
   }
   if (F.user_empty())
     F.eraseFromParent();
 }
 
 static bool lowerIntrinsics(Module &M) {
   bool Updated = false;
-  static SmallDenseMap<Intrinsic::ID, DXIL::OpCode> LowerMap = {
-      {Intrinsic::sin, DXIL::OpCode::Sin},
-      {Intrinsic::umax, DXIL::OpCode::UMax}};
+
+#define DXIL_OP_INTRINSIC_MAP
+#include "DXILOperation.inc"
+#undef DXIL_OP_INTRINSIC_MAP
+
   for (Function &F : make_early_inc_range(M.functions())) {
     if (!F.isDeclaration())
       continue;
     Intrinsic::ID ID = F.getIntrinsicID();
+    if (ID == Intrinsic::not_intrinsic)
+      continue;
     auto LowerIt = LowerMap.find(ID);
     if (LowerIt == LowerMap.end())
       continue;
     lowerIntrinsic(LowerIt->second, F, M);
     Updated = true;
   }
   return Updated;
 }

llvm/utils/TableGen/DXILEmitter.cpp

struct DXILOperationData {
   int DXILOpID;        // ID of DXIL operation
   StringRef DXILClass; // name of the opcode class
   StringRef Category;  // classification for this instruction
   StringRef Doc;       // the documentation description of this instruction
 
   SmallVector<DXILParam> Params; // the operands that this instruction takes
   StringRef OverloadTypes;       // overload types if applicable
   StringRef FnAttr;              // attribute shorthands: rn=does not access
-                                 // memory,ro=only reads from memory,
-  bool IsDeriv;                  // whether this is some kind of derivative
+                                 // memory,ro=only reads from memory
+  StringRef Intrinsic; // The llvm intrinsic map to DXILOp. Default is "" which
+                       // means no map exist
+  bool IsDeriv;        // whether this is some kind of derivative
   bool IsGradient;               // whether this requires a gradient calculation
   bool IsFeedback;               // whether this is a sampler feedback op
   bool IsWave; // whether this requires in-wave, cross-lane functionality
   bool RequiresUniformInputs; // whether this operation requires that all
                               // of its inputs are uniform across the wave
   SmallVector<StringRef, 4>
       ShaderStages; // shader stages to which this applies, empty for all.
   DXILShaderModel ShaderModel;           // minimum shader model required
   DXILShaderModel ShaderModelTranslated; // minimum shader model required with
                                          // translation by linker
   SmallVector<StringRef, 4> counters;    // counters for this inst.
   DXILOperationData(const Record *R) {
     Name = R->getValueAsString("name");
     DXILOp = R->getValueAsString("dxil_op");
     DXILOpID = R->getValueAsInt("dxil_opid");
     DXILClass = R->getValueAsDef("op_class")->getValueAsString("name");
     Category = R->getValueAsDef("category")->getValueAsString("name");
 
+    if (R->getValue("llvm_intrinsic")) {
+      auto *IntrinsicDef = R->getValueAsDef("llvm_intrinsic");
+      auto DefName = IntrinsicDef->getName();
+      assert(DefName.startswith("int_") && "invalid intrinsic name");
+      // Remove the int_ from intrinsic name.
+      Intrinsic = DefName.substr(4);
+    }
+
     Doc = R->getValueAsString("doc");
+
     ListInit *ParamList = R->getValueAsListInit("ops");
     for (unsigned i = 0; i < ParamList->size(); ++i) {
       Record *Param = ParamList->getElementAsRecord(i);
       Params.emplace_back(DXILParam(Param));
     }
     OverloadTypes = R->getValueAsString("oload_types");
     FnAttr = R->getValueAsString("fn_attr");
   }
if (Category != PrevCategory) {
       PrevCategory = Category;
     }
     StringRef Name = It.first;
     OS << Name << ",\n";
   }
   OS << "\n};\n\n";
 }
 
+// Emit map from llvm intrinsic to DXIL operation.
+static void EmitDXILIntrinsicMap(std::vector<DXILOperationData> &DXILOps,
+                                 raw_ostream &OS) {
+  OS << "\n";
+  // FIXME: use array instead of SmallDenseMap.
+  OS << "static const SmallDenseMap<Intrinsic::ID, DXIL::OpCode> LowerMap = "
+        "{\n";
+  for (auto &DXILOp : DXILOps) {
+    if (DXILOp.Intrinsic.empty())
+      continue;
+    // {Intrinsic::sin, DXIL::OpCode::Sin},
+    OS << "  { Intrinsic::" << DXILOp.Intrinsic
+       << ", DXIL::OpCode::" << DXILOp.DXILOp << "},\n";
+  }
+  OS << "};\n";
+  OS << "\n";
+}
+
 namespace llvm {
 
 void EmitDXILOperation(RecordKeeper &Records, raw_ostream &OS) {
   std::vector<Record *> Ops = Records.getAllDerivedDefinitions("dxil_op");
   OS << "// Generated code, do not edit.\n";
   OS << "\n";
 
   std::vector<DXILOperationData> DXILOps;
   DXILOps.reserve(Ops.size());
   for (auto *Record : Ops) {
     DXILOps.emplace_back(DXILOperationData(Record));
   }
 
   OS << "#ifdef DXIL_OP_ENUM\n";
   emitDXILEnums(DXILOps, OS);
   OS << "#endif\n\n";
 
+  OS << "#ifdef DXIL_OP_INTRINSIC_MAP\n";
+  EmitDXILIntrinsicMap(DXILOps, OS);
+  OS << "#endif\n\n";
+
+
   OS << "\n";
 }
 
 } // namespace llvm