[PowerPC] Add new TableGen backend for instruction mapping table

[shchenz]

This seems like the same/similar semantic with PPCInstPrinter::getMnemonic()?

[qiucf]

Got better way to derive the data from tablegen's dump-json option.

llvm/docs/TableGen/BackEnds.rst

 interface; run 'tdtags -H' for documentation.
 
 X86EVEX2VEX
 -----------
 
 **Purpose**: This X86 specific tablegen backend emits tables that map EVEX
 encoded instructions to their VEX encoded identical instruction.
 
+GenPPCInstrMapping
+------------------
+
+**Purpose**: This PowerPC specific tablegen backend generates the table mapping
+instruction opcode to mnemonics in assembly with other information.
+
 Clang BackEnds
 ==============
 
 ClangAttrClasses
 ----------------
 
 **Purpose**: Creates Attrs.inc, which contains semantic attribute class
 declarations for any attribute in ``Attr.td`` that has not set ``ASTNode = 0``.

llvm/lib/Target/PowerPC/CMakeLists.txt

 tablegen(LLVM PPCGenFastISel.inc -gen-fast-isel)
 tablegen(LLVM PPCGenInstrInfo.inc -gen-instr-info)
 tablegen(LLVM PPCGenMCCodeEmitter.inc -gen-emitter)
 tablegen(LLVM PPCGenRegisterInfo.inc -gen-register-info)
 tablegen(LLVM PPCGenSubtargetInfo.inc -gen-subtarget)
 tablegen(LLVM PPCGenExegesis.inc -gen-exegesis)
 tablegen(LLVM PPCGenRegisterBank.inc -gen-register-bank)
 tablegen(LLVM PPCGenGlobalISel.inc -gen-global-isel)
+tablegen(LLVM PPCGenInstrMapping.inc -gen-ppc-instr-mapping)
 
 add_public_tablegen_target(PowerPCCommonTableGen)
 
 add_llvm_target(PowerPCCodeGen
   GISel/PPCInstructionSelector.cpp
   PPCBoolRetToInt.cpp
   PPCAsmPrinter.cpp
   PPCBranchSelector.cpp

llvm/utils/TableGen/CMakeLists.txt

add_tablegen(llvm-tblgen LLVM
   GlobalISelEmitter.cpp
   InfoByHwMode.cpp
   InstrInfoEmitter.cpp
   InstrDocsEmitter.cpp
   IntrinsicEmitter.cpp
   OptEmitter.cpp
   OptParserEmitter.cpp
   OptRSTEmitter.cpp
+  PPCInstrMappingTableEmitter.cpp
   PredicateExpander.cpp
   PseudoLoweringEmitter.cpp
   RISCVCompressInstEmitter.cpp
   RegisterBankEmitter.cpp
   RegisterInfoEmitter.cpp
   SDNodeProperties.cpp
   SearchableTableEmitter.cpp
   SubtargetEmitter.cpp

llvm/utils/TableGen/PPCInstrMappingTableEmitter.cpp

+//===------- PPCInstrMappingTableEmitter.cpp - PowerPC backend---*- C++ -*-===//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This tablegen backend is responsible for emitting the mapping between
+// instruction opcode and assembly mnemonics for PowerPC target.
+//
+//===----------------------------------------------------------------------===//
+#include "CodeGenTarget.h"
+#include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace llvm;
+
+namespace {
+
+class PPCInstrMappingEmitter {
+  CodeGenTarget Target;
+public:
+  PPCInstrMappingEmitter(RecordKeeper &R) : Target(R) {}
+  // run - Generate the mapping tables.
+  void run(formatted_raw_ostream &OS);
+};
+
+static std::string parseMnemonic(StringRef Name) {
+  // What we get now is the full asm string, and we need to get the first token
+  // that separated by space, which is the instruction mnemonic. We have to
+  // strip the '\n' as some instruction asm string contains the '\n'.
+  // TODO - use asm parser to get the mnemonic.
+  return (std::string)Name.split(' ').first.split('\n').first.split('\t').first;
+}
+
+void PPCInstrMappingEmitter::run(formatted_raw_ostream &OS) {
+  ArrayRef<const CodeGenInstruction *> NumberedInstructions =
+      Target.getInstructionsByEnumValue();
+
+  json::OStream J(OS, 2);
+  J.array([&] {
+    for (const CodeGenInstruction *Inst : NumberedInstructions) {
+      std::string Mnemonic = parseMnemonic(Inst->AsmString);
+      if (!StringRef(Mnemonic).empty()) {
+        J.object([&] {
+          const Record *Rec = Inst->TheDef;
+          J.attribute("Opcode", Rec->getName());
+          J.attribute("Mnemonic", Mnemonic);
+          J.attribute("OpNum", Inst->Operands.size() - Inst->Operands.NumDefs);
+          J.attribute("hasNoSchedulingInfo",
+                      Rec->getValueAsBit("hasNoSchedulingInfo"));
+          J.attributeArray("Predicates", [&] {
+            ListInit *Preds = Rec->getValueAsListInit("Predicates");
+            for (auto Pred : *Preds)
+              J.value(Pred->getAsString());
+          });
+        });
+      }
+    }
+  });
+}
+
+} // end anonymous namespace
+
+namespace llvm {
+
+void EmitPPCInstrMapping(RecordKeeper &RK, raw_ostream &o) {
+  formatted_raw_ostream OS(o);
+  PPCInstrMappingEmitter(RK).run(OS);
+}
+} // namespace llvm

llvm/utils/TableGen/TableGen.cpp

enum ActionType {
   GenGICombiner,
   GenX86EVEX2VEXTables,
   GenX86FoldTables,
   GenRegisterBank,
   GenExegesis,
   GenAutomata,
   GenDirectivesEnumDecl,
   GenDirectivesEnumImpl,
+  GenPPCInstrMapping,
 };
 
 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(
         clEnumValN(GenRegisterBank, "gen-register-bank",
                    "Generate registers bank descriptions"),
         clEnumValN(GenExegesis, "gen-exegesis",
                    "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")));
+                   "Generate directive related implementation code"),
+        clEnumValN(GenPPCInstrMapping, "gen-ppc-instr-mapping",
+                   "Generate PowerPC instruction opcode to assembly mnemonics "
+                   "mapping tables")));
 
 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 GenAutomata:
     EmitAutomata(Records, OS);
     break;
   case GenDirectivesEnumDecl:
     EmitDirectivesDecl(Records, OS);
     break;
   case GenDirectivesEnumImpl:
     EmitDirectivesImpl(Records, OS);
     break;
+  case GenPPCInstrMapping:
+    EmitPPCInstrMapping(Records, OS);
+    break;
   }
 
   return false;
 }
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);

llvm/utils/TableGen/TableGenBackends.h

 void EmitGICombiner(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86EVEX2VEXTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86FoldTables(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 EmitPPCInstrMapping(RecordKeeper &RK, raw_ostream &OS);
 
 } // End llvm namespace
 
 #endif