[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

272

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

230

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

[python3kgae]

llvm/utils/TableGen/DXILEmitter.cpp

230

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/CMakeLists.txt

 add_llvm_component_group(DirectX)
 
 set(LLVM_TARGET_DEFINITIONS DirectX.td)
 
 tablegen(LLVM DirectXGenSubtargetInfo.inc -gen-subtarget)
 
 set(LLVM_TARGET_DEFINITIONS DXIL.td)
 tablegen(LLVM DXILConstants.inc -gen-dxil-enum)
 tablegen(LLVM DXILIntrinsicMap.inc -gen-dxil-intrinsic-map)
+tablegen(LLVM DXILOperationTable.inc -gen-dxil-operation-table)
 
 add_public_tablegen_target(DirectXCommonTableGen)
 
 add_llvm_target(DirectXCodeGen
   DirectXSubtarget.cpp
   DirectXTargetMachine.cpp
   DXILOpLowering.cpp
   DXILPointerType.cpp

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[] = {
-      "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.
+#include "DXILOperationTable.inc"
 
 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},
-  };
-  // 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();
 

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 "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 {
if (Category != PrevCategory) {
       PrevCategory = Category;
     }
     StringRef Name = ClassOp->DXILClass;
     OS << Name << ",\n";
   }
   OS << "\n};\n\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;
+  StringRef PrevCategory = "";
+  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 << "  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 {
 // Emit enum declaration for DXIL.
 void EmitDXILEnum(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) {
     // {Intrinsic::sin, DXIL::OpCode::Sin},
     OS << "  { Intrinsic::" << DXILOp.Intrinsic
        << ", DXIL::OpCode::" << DXILOp.DXILOp << "},\n";
   }
   OS << "};\n";
   OS << "\n";
 }
 
+void EmitDXILOperationTable(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) {
+    DXILOperationData DXILOp(Record);
+    DXILOps.emplace_back(DXILOp);
+  }
+
+  emitDXILOperationTable(DXILOps, OS);
+
+  OS << "\n";
+}
+
 } // namespace llvm

llvm/utils/TableGen/TableGen.cpp

enum ActionType {
   GenX86MnemonicTables,
   GenRegisterBank,
   GenExegesis,
   GenAutomata,
   GenDirectivesEnumDecl,
   GenDirectivesEnumImpl,
   GenDXILEnum,
   GenDXILIntrinsicMap,
+  GenDXILOperationTable,
 };
 
 namespace llvm {
 cl::opt<bool> EmitLongStrLiterals(
     "long-string-literals",
     cl::desc("when emitting large string tables, prefer string literals over "
              "comma-separated char literals. This can be a readability and "
              "compile-time performance win, but upsets some compilers"),
cl::values(
                    "Generate llvm-exegesis tables"),
         clEnumValN(GenAutomata, "gen-automata", "Generate generic automata"),
         clEnumValN(GenDirectivesEnumDecl, "gen-directive-decl",
                    "Generate directive related declaration code (header file)"),
         clEnumValN(GenDirectivesEnumImpl, "gen-directive-impl",
                    "Generate directive related implementation code"),
         clEnumValN(GenDXILEnum, "gen-dxil-enum", "Generate enum for DXIL"),
         clEnumValN(GenDXILIntrinsicMap, "gen-dxil-intrinsic-map",
-                   "Generate map from llvm intrinsic to DXIL operation")));
+                   "Generate map from llvm intrinsic to DXIL operation"),
+        clEnumValN(GenDXILOperationTable, "gen-dxil-operation-table",
+                   "Generate DXIL operation table")));
 
 cl::OptionCategory PrintEnumsCat("Options for -print-enums");
 cl::opt<std::string> Class("class", cl::desc("Print Enum list for this class"),
                            cl::value_desc("class name"),
                            cl::cat(PrintEnumsCat));
 
 bool LLVMTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
   switch (Action) {
case GenDirectivesEnumImpl:
     EmitDirectivesImpl(Records, OS);
     break;
   case GenDXILEnum:
     EmitDXILEnum(Records, OS);
     break;
   case GenDXILIntrinsicMap:
     EmitDXILIntrinsicMap(Records, OS);
     break;
+  case GenDXILOperationTable:
+    EmitDXILOperationTable(Records, OS);
+    break;
   }
 
   return false;
 }
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);

llvm/utils/TableGen/TableGenBackends.h

 void EmitX86MnemonicTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitRegisterBank(RecordKeeper &RK, raw_ostream &OS);
 void EmitExegesis(RecordKeeper &RK, raw_ostream &OS);
 void EmitAutomata(RecordKeeper &RK, raw_ostream &OS);
 void EmitDirectivesDecl(RecordKeeper &RK, raw_ostream &OS);
 void EmitDirectivesImpl(RecordKeeper &RK, raw_ostream &OS);
 void EmitDXILEnum(RecordKeeper &RK, raw_ostream &OS);
 void EmitDXILIntrinsicMap(RecordKeeper &RK, raw_ostream &OS);
+void EmitDXILOperationTable(RecordKeeper &RK, raw_ostream &OS);
 
 } // End llvm namespace
 
 #endif