[TableGen][DirectX] generate DXIL operation table with TableGen.

[python3kgae]

Summary

Add more feature to tableGen backend gen-dxil-operation.

It will generate getOpCodeProperty, getOpCodeClassName and getOpCodeName when build DirectX target.
Each of these functions has a table which generate based on DXIL operations.

These generated functions will replace the manually written functions which used for query DXIL operation information.

[python3kgae]

Move EmitDXILOperationTable gen-dxil-operation

[bogner]

llvm/utils/TableGen/DXILEmitter.cpp

321

Should we assert that we found the opcode here?

[python3kgae]

Add assert to make sure found the opcode.

[hctim]

Hey, looks like this breaks with -Werror. Did a quick revert, PTAL and reland :).

https://lab.llvm.org/buildbot/#/builders/77/builds/18671

FAILED: utils/TableGen/CMakeFiles/llvm-tblgen.dir/DXILEmitter.cpp.o 
CCACHE_CPP2=yes CCACHE_HASHDIR=yes /usr/bin/ccache /var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm_build0/bin/clang++ -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -I/var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm_build64/utils/TableGen -I/var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm-project/llvm/utils/TableGen -I/var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm_build64/include -I/var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm-project/llvm/include -gmlt -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wno-comment -Wstring-conversion -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -O3 -DNDEBUG  -fno-exceptions -fno-rtti -UNDEBUG -std=c++14 -MD -MT utils/TableGen/CMakeFiles/llvm-tblgen.dir/DXILEmitter.cpp.o -MF utils/TableGen/CMakeFiles/llvm-tblgen.dir/DXILEmitter.cpp.o.d -o utils/TableGen/CMakeFiles/llvm-tblgen.dir/DXILEmitter.cpp.o -c /var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm-project/llvm/utils/TableGen/DXILEmitter.cpp
/var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm-project/llvm/utils/TableGen/DXILEmitter.cpp:279:13: error: unused variable 'PrevCategory' [-Werror,-Wunused-variable]
  StringRef PrevCategory = "";
            ^
1 error generated.
[828/4628] Building CXX object lib/MC/MCParser/CMakeFiles/LLVMMCParser.dir/AsmParser.cpp.o

llvm/utils/TableGen/DXILEmitter.cpp

279

Unused variable here, broke the sanitizer build bots that build with -Werror.

[python3kgae]

llvm/utils/TableGen/DXILEmitter.cpp

279

Sorry to miss it.
Rebuilding to make sure no other warnings.

[python3kgae]

Fix warning.

[python3kgae]

Update to make arc happy to land.

llvm/lib/Target/DirectX/DXILOpLowering.cpp

if (Kind < OverloadKind::UserDefineType) {
     Ty->print(OS);
     return OS.str();
   }
 }
 
 // Static properties.
 struct OpCodeProperty {
   DXIL::OpCode OpCode;
-  // FIXME: change OpCodeName into index to a large string constant when move to
-  // tableGen.
-  const char *OpCodeName;
+  // Offset in DXILOpCodeNameTable.
+  unsigned OpCodeNameOffset;
   DXIL::OpCodeClass OpCodeClass;
+  // Offset in DXILOpCodeClassNameTable.
+  unsigned OpCodeClassNameOffset;
   uint16_t OverloadTys;
   llvm::Attribute::AttrKind FuncAttr;
 };
 
-static const char *getOpCodeClassName(const OpCodeProperty &Prop) {
-  // FIXME: generate this table with tableGen.
-  static const char *OpCodeClassNames[] = {
-      "binary",
-      "unary",
-  };
-  unsigned Index = static_cast<unsigned>(Prop.OpCodeClass);
-  assert(Index < (sizeof(OpCodeClassNames) / sizeof(OpCodeClassNames[0])) &&
-         "Out of bound OpCodeClass");
-  return OpCodeClassNames[Index];
-}
+// Include getOpCodeClassName getOpCodeProperty and getOpCodeName which
+// generated by tableGen.
+#define DXIL_OP_OPERATION_TABLE
+#include "DXILOperation.inc"
+#undef DXIL_OP_OPERATION_TABLE
 
 static std::string constructOverloadName(OverloadKind Kind, Type *Ty,
                                          const OpCodeProperty &Prop) {
   if (Kind == OverloadKind::VOID) {
     return (Twine(DXILOpNamePrefix) + getOpCodeClassName(Prop)).str();
   }
   return (Twine(DXILOpNamePrefix) + getOpCodeClassName(Prop) + "." +
           getTypeName(Kind, Ty))
       .str();
 }
 
-static const OpCodeProperty *getOpCodeProperty(DXIL::OpCode DXILOp) {
-  // FIXME: generate this table with tableGen.
-  static const OpCodeProperty OpCodeProps[] = {
-      {DXIL::OpCode::Sin, "Sin", OpCodeClass::Unary,
-       OverloadKind::FLOAT | OverloadKind::HALF, Attribute::AttrKind::ReadNone},
-      {DXIL::OpCode::UMax, "UMax", OpCodeClass::Binary,
-       OverloadKind::I16 | OverloadKind::I32 | OverloadKind::I64,
-       Attribute::AttrKind::ReadNone},
-  };
-  // FIXME: change search to indexing with
-  // DXILOp once all DXIL op is added.
-  OpCodeProperty TmpProp;
-  TmpProp.OpCode = DXILOp;
-  const OpCodeProperty *Prop =
-      llvm::lower_bound(OpCodeProps, TmpProp,
-                        [](const OpCodeProperty &A, const OpCodeProperty &B) {
-                          return A.OpCode < B.OpCode;
-                        });
-  return Prop;
-}
-
 static FunctionCallee createDXILOpFunction(DXIL::OpCode DXILOp, Function &F,
                                            Module &M) {
   const OpCodeProperty *Prop = getOpCodeProperty(DXILOp);
 
   // Get return type as overload type for DXILOp.
   // Only simple mapping case here, so return type is good enough.
   Type *OverloadTy = F.getReturnType();
 
for (User *U : make_early_inc_range(F.users())) {
     if (!CI)
       continue;
 
     SmallVector<Value *> Args;
     Args.emplace_back(DXILOpArg);
     Args.append(CI->arg_begin(), CI->arg_end());
     B.SetInsertPoint(CI);
     CallInst *DXILCI = B.CreateCall(DXILOpFn, Args);
+    LLVM_DEBUG(DXILCI->setName(getOpCodeName(DXILOp)));
     CI->replaceAllUsesWith(DXILCI);
     CI->eraseFromParent();
   }
   if (F.user_empty())
     F.eraseFromParent();
 }
 
 static bool lowerIntrinsics(Module &M) {

llvm/utils/TableGen/DXILEmitter.cpp

 //===- DXILEmitter.cpp - DXIL operation Emitter ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // DXILEmitter uses the descriptions of DXIL operation to construct enum and
 // helper functions for DXIL operation.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/MapVector.h"
+#include "SequenceToOffsetTable.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace llvm;
 
 namespace {
 
 struct DXILShaderModel {
for (auto &It : ClassVec) {
     }
     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,
+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";
 }
 
+static std::string emitDXILOperationFnAttr(StringRef FnAttr) {
+  return StringSwitch<std::string>(FnAttr)
+      .Case("rn", "Attribute::ReadNone")
+      .Case("ro", "Attribute::ReadOnly")
+      .Default("Attribute::None");
+}
+
+static std::string getOverloadKind(StringRef Overload) {
+  return StringSwitch<std::string>(Overload)
+      .Case("half", "OverloadKind::HALF")
+      .Case("float", "OverloadKind::FLOAT")
+      .Case("double", "OverloadKind::DOUBLE")
+      .Case("i1", "OverloadKind::I1")
+      .Case("i16", "OverloadKind::I16")
+      .Case("i32", "OverloadKind::I32")
+      .Case("i64", "OverloadKind::I64")
+      .Case("udt", "OverloadKind::UserDefineType")
+      .Case("obj", "OverloadKind::ObjectType")
+      .Default("OverloadKind::VOID");
+}
+
+static std::string getDXILOperationOverload(StringRef Overloads) {
+  SmallVector<StringRef> OverloadStrs;
+  Overloads.split(OverloadStrs, ';', /*MaxSplit*/ -1, /*KeepEmpty*/ false);
+  // Format is: OverloadKind::FLOAT | OverloadKind::HALF
+  assert(!OverloadStrs.empty() && "Invalid overloads");
+  auto It = OverloadStrs.begin();
+  std::string Result;
+  raw_string_ostream OS(Result);
+  OS << getOverloadKind(*It);
+  for (++It; It != OverloadStrs.end(); ++It) {
+    OS << " | " << getOverloadKind(*It);
+  }
+  return OS.str();
+}
+
+static std::string lowerFirstLetter(StringRef Name) {
+  if (Name.empty())
+    return "";
+
+  std::string LowerName = Name.str();
+  LowerName[0] = llvm::toLower(Name[0]);
+  return LowerName;
+}
+
+static std::string getDXILOpClassName(StringRef DXILOpClass) {
+  // Lower first letter expect for special case.
+  return StringSwitch<std::string>(DXILOpClass)
+      .Case("CBufferLoad", "cbufferLoad")
+      .Case("CBufferLoadLegacy", "cbufferLoadLegacy")
+      .Case("GSInstanceID", "gsInstanceID")
+      .Default(lowerFirstLetter(DXILOpClass));
+}
+
+static void emitDXILOperationTable(std::vector<DXILOperationData> &DXILOps,
+                                   raw_ostream &OS) {
+  // Sort by DXILOpID.
+  std::sort(DXILOps.begin(), DXILOps.end(),
+            [](DXILOperationData &A, DXILOperationData &B) {
+              return A.DXILOpID < B.DXILOpID;
+            });
+
+  // Collect Names.
+  SequenceToOffsetTable<std::string> OpClassStrings;
+  SequenceToOffsetTable<std::string> OpStrings;
+
+  StringSet<> ClassSet;
+  for (auto &DXILOp : DXILOps) {
+    OpStrings.add(DXILOp.DXILOp.str());
+
+    if (ClassSet.find(DXILOp.DXILClass) != ClassSet.end())
+      continue;
+    ClassSet.insert(DXILOp.DXILClass);
+    OpClassStrings.add(getDXILOpClassName(DXILOp.DXILClass));
+  }
+
+  // Layout names.
+  OpStrings.layout();
+  OpClassStrings.layout();
+
+  // Emit the DXIL operation table.
+  //{DXIL::OpCode::Sin, OpCodeNameIndex, OpCodeClass::Unary,
+  // OpCodeClassNameIndex,
+  // OverloadKind::FLOAT | OverloadKind::HALF, Attribute::AttrKind::ReadNone},
+  OS << "static const OpCodeProperty *getOpCodeProperty(DXIL::OpCode DXILOp) "
+        "{\n";
+
+  OS << "  static const OpCodeProperty OpCodeProps[] = {\n";
+  for (auto &DXILOp : DXILOps) {
+    OS << "  { DXIL::OpCode::" << DXILOp.DXILOp << ", "
+       << OpStrings.get(DXILOp.DXILOp.str())
+       << ", OpCodeClass::" << DXILOp.DXILClass << ", "
+       << OpClassStrings.get(getDXILOpClassName(DXILOp.DXILClass)) << ", "
+       << getDXILOperationOverload(DXILOp.OverloadTypes) << ", "
+       << emitDXILOperationFnAttr(DXILOp.FnAttr) << " },\n";
+  }
+  OS << "  };\n";
+
+  OS << "  // FIXME: change search to indexing with\n";
+  OS << "  // DXILOp once all DXIL op is added.\n";
+  OS << "  OpCodeProperty TmpProp;\n";
+  OS << "  TmpProp.OpCode = DXILOp;\n";
+  OS << "  const OpCodeProperty *Prop =\n";
+  OS << "      llvm::lower_bound(OpCodeProps, TmpProp,\n";
+  OS << "                        [](const OpCodeProperty &A, const "
+        "OpCodeProperty &B) {\n";
+  OS << "                          return A.OpCode < B.OpCode;\n";
+  OS << "                        });\n";
+  OS << "  assert(Prop && \"fail to find OpCodeProperty\");\n";
+  OS << "  return Prop;\n";
+  OS << "}\n\n";
+
+  // Emit the string tables.
+  OS << "static const char *getOpCodeName(DXIL::OpCode DXILOp) {\n\n";
+
+  OpStrings.emitStringLiteralDef(OS,
+                                 "  static const char DXILOpCodeNameTable[]");
+
+  OS << "  auto *Prop = getOpCodeProperty(DXILOp);\n";
+  OS << "  unsigned Index = Prop->OpCodeNameOffset;\n";
+  OS << "  return DXILOpCodeNameTable + Index;\n";
+  OS << "}\n\n";
+
+  OS << "static const char *getOpCodeClassName(const OpCodeProperty &Prop) "
+        "{\n\n";
+
+  OpClassStrings.emitStringLiteralDef(
+      OS, "  static const char DXILOpCodeClassNameTable[]");
+
+  OS << "  unsigned Index = Prop.OpCodeClassNameOffset;\n";
+  OS << "  return DXILOpCodeClassNameTable + Index;\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);
+  emitDXILIntrinsicMap(DXILOps, OS);
   OS << "#endif\n\n";
 
+  OS << "#ifdef DXIL_OP_OPERATION_TABLE\n";
+  emitDXILOperationTable(DXILOps, OS);
+  OS << "#endif\n\n";
 
   OS << "\n";
 }
 
 } // namespace llvm