Refactor Tblgen DecoderEmitter to allow multiple language output

[Rot127]

Summary

This refactor of the TableGen DecoderEmitter allows to output the generated code in different languages (C is added here).

Please note that this review request is for feedback purpose only and not meant to be merged.

The changes were made on branch llvm-15.0.3.

Justification

The necessity for this refactor came from our wish at Capstone to generate the decoder tables and decoder methods/functions in C and not C++.
Simply patching our fork would have ended in regular maintenance work which we would like to avoid (especially since we had to do it for at least four backends).
Since translating the generated C++ to C with scripts is a mess we wanted a more fundamental solution.

Summary

The refactor does the following:

1. To allow multiple language output of this backend, all the generated strings are managed by class inherited from PrinterInterface (see details below).
2. Splits the single DecoderEmitter.cpp file into multiple files for readability purposes and unites them under their own namespace.
3. Adds a sequence diagram about the generation process (to give a rough overview).
4. Adds documentation how the decoder works (state machine) and describes how the decoding state machine is build.
5. For readability some very long methods were shortened by extracting code into separated methods.
6. The generation logic was not touched in any way (Except two variable renamings so they match the documentation (FilteredInstructions -> FilteredInstrSubsets, VariableInstructions -> VariableInstrSubsets)).

The newly introduced "Printer" classes (PrinterInterface and children) handle all strings which are emitted into the output stream.
For each language there exists an implementation of the abstract PrinterInterface (here C++ and C for Capstone).

The DecoderEmitter and FilterChooser have an instance of a PrinterInterface and request strings from it or trigger the writing of the code to the output stream.
Depending on the language which should be written a different implementation of the PrinterInterface is set in DecoderEmitter and FilterChooser.

Feedback request

Other backends which emit code would need a "PrinterInterface" as well (e.g. AsmWriter, RegisterInfo, InstrInfo, SubtargetInfo).

The changes made here are a lot. Hence I don't expect and wouldn't want them to be merged.
But I kindly ask you for your feedback.

[0x59616e]

Thanks for this patch !

It is difficult to see the changes you made. Could you separate this into two patches -- the first one contains the all the changes except the functional change; the second one contains the functional change you made.

[myhsu]

I only skimmed through the patch but I found this pretty interesting. To my best understanding, you're trying to add another layer of abstraction between disassembler generation logics and the code printer. Such that downstream projects like Capstone only need to maintain a single printer code (e.g. PrinterCapston.cpp) rather than hundreds of lines of code spanning across DecoderEmitter.cpp. If this is the case, I strongly encourage you to upstream most of the stuff here except PrinterCapstone.cpp.

Other backends which emit code would need a "PrinterInterface" as well (e.g. AsmWriter, RegisterInfo, InstrInfo, SubtargetInfo).

We can try on the disassembler first and gradually refactor other components later in other patches (because this new printer interface can co-exist with the current code printing logics, right?)

llvm/utils/TableGen/DecoderEmitter/CMakeLists.txt

6

double quotes are not necessary here, please remove them for better readability

llvm/utils/TableGen/DecoderEmitter/README.md

2

Kudos on this document!

[Rot127]

Adds the decoder split up/refactor as single diff. separated from the Printer implementation.

[Rot127]

Add diff of Printer implementation.

[Rot127]

In D136808#3888064, @0x59616e wrote:

Thanks for this patch !

It is difficult to see the changes you made. Could you separate this into two patches -- the first one contains the all the changes except the functional change; the second one contains the functional change you made.

I updated the diff two more times they can be selected now in the history. Hopefully this was the right way of doing it?
Sorry if not. I'm new to Phabricator but wanted to have it available quickly for you guys.

There are only two none functional changes in the functional commit: one renaming of the statistic variables and the extraction of types from one header file to another (easy to spot).
Sorry if this isn't 100% clean, but those changes were made too late and couldn't easily be resorted with git rebase -i.

[Rot127]

In D136808#3888821, @myhsu wrote:

To my best understanding, you're trying to add another layer of abstraction between disassembler generation logics and the code printer. Such that downstream projects like Capstone only need to maintain a single printer code (e.g. PrinterCapston.cpp) rather than hundreds of lines of code spanning across DecoderEmitter.cpp

Yes, this is the idea.

In D136808#3888821, @myhsu wrote:

because this new printer interface can co-exist with the current code printing logics, right?

In what sense do you mean "co-exist"?
Currently the generator logic writes to OS whenever it has some code piece ready (this seems to be the case for all backends mentioned above).
With this change it no longer does it, but passes the generated code pieces on. Once all the code is generated the Printer writes it to OS.

So as long as one backend is updated at a time there is no problem. Since backends do not share printing logic in any way.

[myhsu]

In D136808#3890589, @Rot127 wrote:

So as long as one backend is updated at a time there is no problem. Since backends do not share printing logic in any way.

Yes I was simply wondering if it's possible to update a single backend a time. Good to know now.

[Rot127]

There is now an implementation open for review: https://reviews.llvm.org/D138323

llvm/utils/TableGen/DecoderEmitter/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   TableGen
   )
 
 add_llvm_library(LLVMTableDecoderEmitter LINK_COMPONENTS DISABLE_LLVM_LINK_LLVM_DYLIB
   "DecoderEmitter.cpp"
   "Filter.cpp"
   "FilterChooser.cpp"
   "HelperFunctions.cpp"
+  "PrinterCapstone.cpp"
+  "PrinterLLVM.cpp"
   )

llvm/utils/TableGen/DecoderEmitter/DecoderEmitter.h

 //===----------- DecoderEmitter.h - Decoder Generator -----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_UTILS_TABLEGEN_DECODEREMITTER_DECODEREMITTER_H
 #define LLVM_UTILS_TABLEGEN_DECODEREMITTER_DECODEREMITTER_H
 
-#include "../CodeGenInstruction.h"
-#include "../CodeGenTarget.h"
-#include "../InfoByHwMode.h"
-#include "../VarLenCodeEmitterGen.h"
-#include "llvm/ADT/APInt.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/CachedHashString.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SetVector.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/Statistic.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/MC/MCDecoderOps.h"
-#include "llvm/Support/Casting.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/FormattedStream.h"
-#include "llvm/Support/LEB128.h"
-#include "llvm/Support/raw_ostream.h"
-#include "llvm/TableGen/Error.h"
-#include "llvm/TableGen/Record.h"
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
+#include "DecoderEmitterTypes.h"
+#include "Printer.h"
 
 using namespace llvm;
 
 namespace tblgen_decoder_emitter {
 
 //////////////////////
-// Structs and Types
-//////////////////////
-
-struct EncodingField {
-  unsigned Base, Width, Offset;
-  EncodingField(unsigned B, unsigned W, unsigned O)
-      : Base(B), Width(W), Offset(O) {}
-};
-
-struct OperandInfo {
-  std::vector<EncodingField> Fields;
-  std::string Decoder;
-  bool HasCompleteDecoder;
-  uint64_t InitValue;
-
-  OperandInfo(std::string D, bool HCD)
-      : Decoder(std::move(D)), HasCompleteDecoder(HCD), InitValue(0) {}
-
-  void addField(unsigned Base, unsigned Width, unsigned Offset) {
-    Fields.push_back(EncodingField(Base, Width, Offset));
-  }
-
-  unsigned numFields() const { return Fields.size(); }
-
-  typedef std::vector<EncodingField>::const_iterator const_iterator;
-
-  const_iterator begin() const { return Fields.begin(); }
-  const_iterator end() const { return Fields.end(); }
-};
-
-typedef std::vector<uint8_t> DecoderTable;
-typedef uint32_t DecoderFixup;
-typedef std::vector<DecoderFixup> FixupList;
-typedef std::vector<FixupList> FixupScopeList;
-typedef SmallSetVector<CachedHashString, 16> PredicateSet;
-typedef SmallSetVector<CachedHashString, 16> DecoderSet;
-struct DecoderTableInfo {
-  DecoderTable Table;
-  FixupScopeList FixupStack;
-  PredicateSet Predicates;
-  DecoderSet Decoders;
-};
-
-struct EncodingAndInst {
-  const Record *EncodingDef;
-  const CodeGenInstruction *Inst;
-  StringRef HwModeName;
-
-  EncodingAndInst(const Record *EncodingDef, const CodeGenInstruction *Inst,
-                  StringRef HwModeName = "")
-      : EncodingDef(EncodingDef), Inst(Inst), HwModeName(HwModeName) {}
-};
-
-struct EncodingIDAndOpcode {
-  unsigned EncodingID;
-  unsigned Opcode;
-
-  EncodingIDAndOpcode() : EncodingID(0), Opcode(0) {}
-  EncodingIDAndOpcode(unsigned EncodingID, unsigned Opcode)
-      : EncodingID(EncodingID), Opcode(Opcode) {}
-};
-
-inline raw_ostream &operator<<(raw_ostream &OS, const EncodingAndInst &Value) {
-  if (Value.EncodingDef != Value.Inst->TheDef)
-    OS << Value.EncodingDef->getName() << ":";
-  OS << Value.Inst->TheDef->getName();
-  return OS;
-}
-
-// The set (BIT_TRUE, BIT_FALSE, BIT_UNSET) represents a ternary logic system
-// for a bit value.
-//
-// BIT_UNFILTERED is used as the init value for a filter position.  It is used
-// only for filter processings.
-typedef enum {
-  BIT_TRUE,      // '1'
-  BIT_FALSE,     // '0'
-  BIT_UNSET,     // '?'
-  BIT_UNFILTERED // unfiltered
-} bit_value_t;
-
-// Representation of the instruction to work on.
-typedef std::vector<bit_value_t> insn_t;
-
-static const uint64_t NoFixedSegmentsSentinel = -1ULL;
-
-//////////////////////
 // Functions
 //////////////////////
 
 std::string findOperandDecoderMethod(Record *Record);
 
 OperandInfo getOpInfo(Record *TypeRecord);
 
 void parseVarLenInstOperand(const Record &Def,
                             std::vector<OperandInfo> &Operands,
                             const CodeGenInstruction &CGI);
 
 unsigned
 populateInstruction(CodeGenTarget &Target, const Record &EncodingDef,
                     const CodeGenInstruction &CGI, unsigned Opc,
                     std::map<unsigned, std::vector<OperandInfo>> &Operands,
                     bool IsVarLenInst);
 
-// emitFieldFromInstruction - Emit the templated helper function
-// fieldFromInstruction().
-// On Windows we make sure that this function is not inlined when
-// using the VS compiler. It has a bug which causes the function
-// to be optimized out in some circustances. See llvm.org/pr38292
-void emitFieldFromInstruction(formatted_raw_ostream &OS);
-
-// emitInsertBits - Emit the templated helper function insertBits().
-void emitInsertBits(formatted_raw_ostream &OS);
-
-// emitDecodeInstruction - Emit the templated helper function
-// decodeInstruction().
-void emitDecodeInstruction(formatted_raw_ostream &OS, bool IsVarLenInst);
-
 bool valueSet(bit_value_t V);
 
 bool valueNotSet(bit_value_t V);
 
 int value(bit_value_t V);
 
 bit_value_t bitFromBits(const BitsInit &Bits, unsigned Index);
 

 // Classes
 //////////////////////
 
 class FilterChooser;
 class Filter;
 
 class DecoderEmitter {
   RecordKeeper &RK;
+  const PrinterInterface &PI;
   std::vector<EncodingAndInst> NumberedEncodings;
 
   ArrayRef<const CodeGenInstruction *> NumberedInstructions;
   DenseMap<Record *, unsigned> IndexOfInstruction;
   // The opcode map.
   // It maps the DecoderNamespace (e.g. ARM Thumb16) and instruction sizes
   // to the encodings which belong into this subset.
   std::map<std::pair<std::string, unsigned>, std::vector<EncodingIDAndOpcode>>
       OpcMap;
   std::map<unsigned, std::vector<OperandInfo>> Operands;
   std::vector<unsigned> InstrLen;
 
 public:
   // Defaults preserved here for documentation, even though they aren't
   // strictly necessary given the way that this is currently being called.
-  DecoderEmitter(RecordKeeper &R, std::string PredicateNamespace,
-                 std::string GPrefix = "if (",
-                 std::string GPostfix = " == MCDisassembler::Fail)",
-                 std::string ROK = "MCDisassembler::Success",
-                 std::string RFail = "MCDisassembler::Fail", std::string L = "")
-      : RK(R), NumberedInstructions(nullptr), Target(R),
-        PredicateNamespace(std::move(PredicateNamespace)), GuardPrefix(std::move(GPrefix)),
-        GuardPostfix(std::move(GPostfix)), ReturnOK(std::move(ROK)),
-        ReturnFail(std::move(RFail)), Locals(std::move(L)) {}
-
-  // Emit the decoder state machine table.
-  void emitTable(formatted_raw_ostream &O, DecoderTable &Table,
-                 unsigned Indentation, unsigned BitWidth,
-                 StringRef Namespace) const;
-  void emitInstrLenTable(formatted_raw_ostream &OS,
-                         std::vector<unsigned> &InstrLen) const;
-  void emitPredicateFunction(formatted_raw_ostream &OS,
-                             PredicateSet &Predicates,
-                             unsigned Indentation) const;
-  void emitDecoderFunction(formatted_raw_ostream &OS, DecoderSet &Decoders,
-                           unsigned Indentation) const;
+  DecoderEmitter(RecordKeeper &R, const PrinterInterface &PI)
+      : RK(R), PI(PI), NumberedInstructions(nullptr), Target(R) {}
   void retrieveHwModeEncodings();
-  unsigned
-  fillOpcMap(bool const IsVarLenInst);
+  unsigned fillOpcMap(bool const IsVarLenInst);
 
   // run - Output the code emitter
-  void run(raw_ostream &O);
+  void run();
 
 private:
   CodeGenTarget Target;
-
-public:
-  std::string PredicateNamespace;
-  std::string GuardPrefix, GuardPostfix;
-  std::string ReturnOK, ReturnFail;
-  std::string Locals;
 };
 
 /// Filter - Filter works with FilterChooser to produce the decoding tree for
 /// the ISA.
 ///
 /// It is useful to think of a Filter as governing the switch stmts of the
 /// decoding tree in a certain level.  Each case stmt delegates to an inferior
 /// FilterChooser to decide what further decoding logic to employ, or in

 protected:
   const FilterChooser
       *Owner;        // points to the FilterChooser who owns this filter
   unsigned StartBit; // the starting bit position
   unsigned NumBits;  // number of bits to filter
   bool Mixed;        // a mixed region contains both set and unset bits
 
   // Map of well-known segment value to the set of uid's with that value.
-  std::map<uint64_t, std::vector<EncodingIDAndOpcode>> FilteredInstructions;
+  std::map<uint64_t, std::vector<EncodingIDAndOpcode>> FilteredInstrSubsets;
 
   // Set of uid's with non-constant segment values.
-  std::vector<EncodingIDAndOpcode> VariableInstructions;
+  std::vector<EncodingIDAndOpcode> VariableInstrSubset;
 
   // Map of well-known segment value to its delegate.
   std::map<uint64_t, std::unique_ptr<const FilterChooser>> FilterChooserMap;
 
   // Number of instructions which fall under FilteredInstructions category.
   unsigned NumFiltered;
 
   // Keeps track of the last opcode in the filtered bucket.
public:
   // bits.
   void emitTableEntry(DecoderTableInfo &TableInfo) const;
 
   // Returns the number of fanout produced by the filter.  More fanout implies
   // the filter distinguishes more categories of instructions.
   unsigned usefulness() const;
 }; // end class Filter
 
-// These are states of our finite state machines used in FilterChooser's
-// filterProcessor() which produces the filter candidates to use.
-typedef enum {
-  ATTR_NONE,
-  ATTR_FILTERED,
-  ATTR_ALL_SET,
-  ATTR_ALL_UNSET,
-  ATTR_MIXED
-} bitAttr_t;
-
 /// FilterChooser - FilterChooser chooses the best filter among a set of
 /// Filters in order to perform the decoding of instructions at the current
 /// level.
 ///
 /// Decoding proceeds from the top down.  Based on the well-known encoding
 /// bits of instructions available, FilterChooser builds up the possible
 /// Filters that can further the task of decoding by distinguishing among the
 /// remaining candidate instructions.
 ///
 /// Once a filter has been chosen, it is called upon to divide the decoding
 /// task into sub-tasks and delegates them to its inferior FilterChoosers for
 /// further processings.
 ///
 /// It is useful to think of a Filter as governing the switch stmts of the
 /// decoding tree.  And each case is delegated to an inferior FilterChooser to
 /// decide what further remaining bits to look at.
 class FilterChooser {
 protected:
   friend class Filter;
 
+  // The PrinterInterface to emit source code from.
+  const PrinterInterface &PI;
+
   // Vector of codegen instructions to choose our filter.
   ArrayRef<EncodingAndInst> AllInstructions;
 
   // Vector of uid's for this filter chooser to work on.
   // The first member of the pair is the opcode id being decoded, the second
   // is the opcode id that should be emitted.
   const std::vector<EncodingIDAndOpcode> &Opcodes;
 
protected:
   const FilterChooser *Parent;
 
   // Index of the best filter from Filters.
   int BestIndex;
 
   // Width of instructions
   unsigned BitWidth;
 
-  // Parent emitter
-  const DecoderEmitter *Emitter;
-
 public:
-  FilterChooser(ArrayRef<EncodingAndInst> Insts,
+  FilterChooser(const PrinterInterface &PI, ArrayRef<EncodingAndInst> Insts,
                 const std::vector<EncodingIDAndOpcode> &IDs,
                 const std::map<unsigned, std::vector<OperandInfo>> &Ops,
-                unsigned BW, const DecoderEmitter *E)
-      : AllInstructions(Insts), Opcodes(IDs), Operands(Ops),
+                unsigned BW)
+      : PI(PI), AllInstructions(Insts), Opcodes(IDs), Operands(Ops),
         FilterBitValues(BW, BIT_UNFILTERED), Parent(nullptr), BestIndex(-1),
-        BitWidth(BW), Emitter(E) {
+        BitWidth(BW) {
     doFilter();
   }
 
-  FilterChooser(ArrayRef<EncodingAndInst> Insts,
+  FilterChooser(const PrinterInterface &PI, ArrayRef<EncodingAndInst> Insts,
                 const std::vector<EncodingIDAndOpcode> &IDs,
                 const std::map<unsigned, std::vector<OperandInfo>> &Ops,
                 const std::vector<bit_value_t> &ParentFilterBitValues,
                 const FilterChooser &Parent)
-      : AllInstructions(Insts), Opcodes(IDs), Operands(Ops),
+      : PI(Parent.PI), AllInstructions(Insts), Opcodes(IDs), Operands(Ops),
         FilterBitValues(ParentFilterBitValues), Parent(&Parent), BestIndex(-1),
-        BitWidth(Parent.BitWidth), Emitter(Parent.Emitter) {
+        BitWidth(Parent.BitWidth) {
     doFilter();
   }
 
   FilterChooser(const FilterChooser &) = delete;
   void operator=(const FilterChooser &) = delete;
 
   unsigned getBitWidth() const { return BitWidth; }
 
protected:
   // This returns a lit of undecoded bits of an instructions, for example,
   // Inst{20} = 1 && Inst{3-0} == 0b1111 represents two islands of yet-to-be
   // decoded bits in order to verify that the instruction matches the Opcode.
   unsigned getIslands(std::vector<unsigned> &StartBits,
                       std::vector<unsigned> &EndBits,
                       std::vector<uint64_t> &FieldVals,
                       const insn_t &Insn) const;
 
-  // Emits code to check the Predicates member of an instruction are true.
-  // Returns true if predicate matches were emitted, false otherwise.
-  bool emitPredicateMatch(raw_ostream &O, unsigned &Indentation,
-                          unsigned Opc) const;
-  bool emitPredicateMatchAux(const Init &Val, bool ParenIfBinOp,
-                             raw_ostream &OS) const;
-
   bool doesOpcodeNeedPredicate(unsigned Opc) const;
   unsigned getPredicateIndex(DecoderTableInfo &TableInfo, StringRef P) const;
   void emitPredicateTableEntry(DecoderTableInfo &TableInfo, unsigned Opc) const;
 
   void emitSoftFailTableEntry(DecoderTableInfo &TableInfo, unsigned Opc) const;
 
   // Emits table entries to decode the singleton.
   void emitSingletonTableEntry(DecoderTableInfo &TableInfo,
                                EncodingIDAndOpcode Opc) const;
 
   // Emits code to decode the singleton, and then to decode the rest.
   void emitSingletonTableEntry(DecoderTableInfo &TableInfo,
                                const Filter &Best) const;
 
-  void emitBinaryParser(raw_ostream &O, unsigned &Indentation,
-                        const OperandInfo &OpInfo,
-                        bool &OpHasCompleteDecoder) const;
-
-  void emitDecoder(raw_ostream &OS, unsigned Indentation, unsigned Opc,
+  void emitDecoder(raw_ostream &DecoderOS, unsigned Opc,
                    bool &HasCompleteDecoder) const;
   unsigned getDecoderIndex(DecoderSet &Decoders, unsigned Opc,
                            bool &HasCompleteDecoder) const;
 
   // Assign a single filter and run with it.
   void runSingleFilter(unsigned StartBit, unsigned NumBit, bool Mixed);
 
   // reportRegion is a helper function for filterProcessor to mark a region as

llvm/utils/TableGen/DecoderEmitter/DecoderEmitter.cpp

 //===------------ DecoderEmitter.cpp - Decoder Generator --------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // It contains the tablegen backend that emits the decoder functions for
 // targets with fixed/variable length instruction set.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DecoderEmitter.h"
+#include "../TableGenBackends.h"
 
 using namespace llvm;
 namespace tblgen_decoder_emitter {
 
 #define DEBUG_TYPE "decoder-emitter-DecoderEmitter"
 
-STATISTIC(NumEncodings, "Number of encodings considered");
-STATISTIC(NumEncodingsLackingDisasm, "Number of encodings without disassembler info");
-STATISTIC(NumInstructions, "Number of instructions considered");
-STATISTIC(NumEncodingsOmitted, "Number of encodings omitted");
-
-// Emit the decoder state machine table.
-void DecoderEmitter::emitTable(formatted_raw_ostream &OS, DecoderTable &Table,
-                               unsigned Indentation, unsigned BitWidth,
-                               StringRef Namespace) const {
-  OS.indent(Indentation) << "static const uint8_t DecoderTable" << Namespace
-    << BitWidth << "[] = {\n";
-
-  Indentation += 2;
-
-  // FIXME: We may be able to use the NumToSkip values to recover
-  // appropriate indentation levels.
-  DecoderTable::const_iterator I = Table.begin();
-  DecoderTable::const_iterator const E = Table.end();
-  while (I != E) {
-    assert (I < E && "incomplete decode table entry!");
-
-    uint64_t const Pos = I - Table.begin();
-    OS << "/* " << Pos << " */";
-    OS.PadToColumn(12);
+STATISTIC(StatsNumEncodings, "Number of encodings considered");
+STATISTIC(StatsNumEncodingsLackingDisasm,
+          "Number of encodings without disassembler info");
+STATISTIC(StatsNumInstructions, "Number of instructions considered");
+STATISTIC(StatsNumEncodingsOmitted, "Number of encodings omitted");
 
-    switch (*I) {
-    default:
-      PrintFatalError("invalid decode table opcode");
-    case MCD::OPC_ExtractField: {
-      ++I;
-      unsigned const Start = *I++;
-      unsigned const Len = *I++;
-      OS.indent(Indentation) << "MCD::OPC_ExtractField, " << Start << ", "
-        << Len << ",  // Inst{";
-      if (Len > 1)
-        OS << (Start + Len - 1) << "-";
-      OS << Start << "} ...\n";
-      break;
-    }
-    case MCD::OPC_FilterValue: {
-      ++I;
-      OS.indent(Indentation) << "MCD::OPC_FilterValue, ";
-      // The filter value is ULEB128 encoded.
-      while (*I >= 128)
-        OS << (unsigned)*I++ << ", ";
-      OS << (unsigned)*I++ << ", ";
-
-      // 24-bit numtoskip value.
-      uint8_t Byte = *I++;
-      uint32_t NumToSkip = Byte;
-      OS << (unsigned)Byte << ", ";
-      Byte = *I++;
-      OS << (unsigned)Byte << ", ";
-      NumToSkip |= Byte << 8;
-      Byte = *I++;
-      OS << utostr(Byte) << ", ";
-      NumToSkip |= Byte << 16;
-      OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
-      break;
-    }
-    case MCD::OPC_CheckField: {
-      ++I;
-      unsigned const Start = *I++;
-      unsigned const Len = *I++;
-      OS.indent(Indentation) << "MCD::OPC_CheckField, " << Start << ", "
-        << Len << ", ";// << Val << ", " << NumToSkip << ",\n";
-      // ULEB128 encoded field value.
-      for (; *I >= 128; ++I)
-        OS << (unsigned)*I << ", ";
-      OS << (unsigned)*I++ << ", ";
-      // 24-bit numtoskip value.
-      uint8_t Byte = *I++;
-      uint32_t NumToSkip = Byte;
-      OS << (unsigned)Byte << ", ";
-      Byte = *I++;
-      OS << (unsigned)Byte << ", ";
-      NumToSkip |= Byte << 8;
-      Byte = *I++;
-      OS << utostr(Byte) << ", ";
-      NumToSkip |= Byte << 16;
-      OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
-      break;
-    }
-    case MCD::OPC_CheckPredicate: {
-      ++I;
-      OS.indent(Indentation) << "MCD::OPC_CheckPredicate, ";
-      for (; *I >= 128; ++I)
-        OS << (unsigned)*I << ", ";
-      OS << (unsigned)*I++ << ", ";
-
-      // 24-bit numtoskip value.
-      uint8_t Byte = *I++;
-      uint32_t NumToSkip = Byte;
-      OS << (unsigned)Byte << ", ";
-      Byte = *I++;
-      OS << (unsigned)Byte << ", ";
-      NumToSkip |= Byte << 8;
-      Byte = *I++;
-      OS << utostr(Byte) << ", ";
-      NumToSkip |= Byte << 16;
-      OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
-      break;
-    }
-    case MCD::OPC_Decode:
-    case MCD::OPC_TryDecode: {
-      bool const IsTry = *I == MCD::OPC_TryDecode;
-      ++I;
-      // Extract the ULEB128 encoded Opcode to a buffer.
-      uint8_t Buffer[16], *P = Buffer;
-      while ((*P++ = *I++) >= 128)
-        assert((P - Buffer) <= (ptrdiff_t)sizeof(Buffer)
-               && "ULEB128 value too large!");
-      // Decode the Opcode value.
-      unsigned const Opc = decodeULEB128(Buffer);
-      OS.indent(Indentation) << "MCD::OPC_" << (IsTry ? "Try" : "")
-        << "Decode, ";
-      for (P = Buffer; *P >= 128; ++P)
-        OS << (unsigned)*P << ", ";
-      OS << (unsigned)*P << ", ";
-
-      // Decoder index.
-      for (; *I >= 128; ++I)
-        OS << (unsigned)*I << ", ";
-      OS << (unsigned)*I++ << ", ";
-
-      if (!IsTry) {
-        OS << "// Opcode: " << NumberedEncodings[Opc] << "\n";
-        break;
-      }
-
-      // Fallthrough for OPC_TryDecode.
-
-      // 24-bit numtoskip value.
-      uint8_t Byte = *I++;
-      uint32_t NumToSkip = Byte;
-      OS << (unsigned)Byte << ", ";
-      Byte = *I++;
-      OS << (unsigned)Byte << ", ";
-      NumToSkip |= Byte << 8;
-      Byte = *I++;
-      OS << utostr(Byte) << ", ";
-      NumToSkip |= Byte << 16;
-
-      OS << "// Opcode: " << NumberedEncodings[Opc]
-         << ", skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
-      break;
-    }
-    case MCD::OPC_SoftFail: {
-      ++I;
-      OS.indent(Indentation) << "MCD::OPC_SoftFail";
-      // Positive mask
-      uint64_t Value = 0;
-      unsigned Shift = 0;
-      do {
-        OS << ", " << (unsigned)*I;
-        Value += (*I & 0x7f) << Shift;
-        Shift += 7;
-      } while (*I++ >= 128);
-      if (Value > 127) {
-        OS << " /* 0x";
-        OS.write_hex(Value);
-        OS << " */";
-      }
-      // Negative mask
-      Value = 0;
-      Shift = 0;
-      do {
-        OS << ", " << (unsigned)*I;
-        Value += (*I & 0x7f) << Shift;
-        Shift += 7;
-      } while (*I++ >= 128);
-      if (Value > 127) {
-        OS << " /* 0x";
-        OS.write_hex(Value);
-        OS << " */";
-      }
-      OS << ",\n";
-      break;
-    }
-    case MCD::OPC_Fail: {
-      ++I;
-      OS.indent(Indentation) << "MCD::OPC_Fail,\n";
-      break;
-    }
-    }
-  }
-  OS.indent(Indentation) << "0\n";
-
-  Indentation -= 2;
-
-  OS.indent(Indentation) << "};\n\n";
-}
-
-void DecoderEmitter::emitInstrLenTable(formatted_raw_ostream &OS,
-                                       std::vector<unsigned> &InstrLen) const {
-  OS << "static const uint8_t InstrLenTable[] = {\n";
-  for (unsigned  const&Len : InstrLen) {
-    OS << Len << ",\n";
-  }
-  OS << "};\n\n";
-}
-
-void DecoderEmitter::emitPredicateFunction(formatted_raw_ostream &OS,
-                                           PredicateSet &Predicates,
-                                           unsigned Indentation) const {
-  // The predicate function is just a big switch statement based on the
-  // input predicate index.
-  OS.indent(Indentation) << "static bool checkDecoderPredicate(unsigned Idx, "
-    << "const FeatureBitset &Bits) {\n";
-  Indentation += 2;
-  if (!Predicates.empty()) {
-    OS.indent(Indentation) << "switch (Idx) {\n";
-    OS.indent(Indentation) << "default: llvm_unreachable(\"Invalid index!\");\n";
-    unsigned Index = 0;
-    for (const auto &Predicate : Predicates) {
-      OS.indent(Indentation) << "case " << Index++ << ":\n";
-      OS.indent(Indentation+2) << "return (" << Predicate << ");\n";
-    }
-    OS.indent(Indentation) << "}\n";
-  } else {
-    // No case statement to emit
-    OS.indent(Indentation) << "llvm_unreachable(\"Invalid index!\");\n";
-  }
-  Indentation -= 2;
-  OS.indent(Indentation) << "}\n\n";
-}
-
-void DecoderEmitter::emitDecoderFunction(formatted_raw_ostream &OS,
-                                         DecoderSet &Decoders,
-                                         unsigned Indentation) const {
-  // The decoder function is just a big switch statement based on the
-  // input decoder index.
-  OS.indent(Indentation) << "template <typename InsnType>\n";
-  OS.indent(Indentation) << "static DecodeStatus decodeToMCInst(DecodeStatus S,"
-    << " unsigned Idx, InsnType insn, MCInst &MI,\n";
-  OS.indent(Indentation)
-      << "                                   uint64_t "
-      << "Address, const MCDisassembler *Decoder, bool &DecodeComplete) {\n";
-  Indentation += 2;
-  OS.indent(Indentation) << "DecodeComplete = true;\n";
-  // TODO: When InsnType is large, using uint64_t limits all fields to 64 bits
-  // It would be better for emitBinaryParser to use a 64-bit tmp whenever
-  // possible but fall back to an InsnType-sized tmp for truly large fields.
-  OS.indent(Indentation) << "using TmpType = "
-                            "std::conditional_t<std::is_integral<InsnType>::"
-                            "value, InsnType, uint64_t>;\n";
-  OS.indent(Indentation) << "TmpType tmp;\n";
-  OS.indent(Indentation) << "switch (Idx) {\n";
-  OS.indent(Indentation) << "default: llvm_unreachable(\"Invalid index!\");\n";
-  unsigned Index = 0;
-  for (const auto &Decoder : Decoders) {
-    OS.indent(Indentation) << "case " << Index++ << ":\n";
-    OS << Decoder;
-    OS.indent(Indentation+2) << "return S;\n";
-  }
-  OS.indent(Indentation) << "}\n";
-  Indentation -= 2;
-  OS.indent(Indentation) << "}\n\n";
-}
-
-/// Encodings of instructions might differ if the Hardware Mode is different as well.
-/// Here we add all possible encodings.
+/// Encodings of instructions might differ if the Hardware Mode is different as
+/// well. Here we add all possible encodings.
 void DecoderEmitter::retrieveHwModeEncodings() {
   std::set<StringRef> HwModeNames;
 
   // First, collect all HwModes referenced by the target.
   for (const auto &NumberedInstruction : NumberedInstructions) {
     IndexOfInstruction[NumberedInstruction->TheDef] = NumberedEncodings.size();
 
     if (const RecordVal *RV =
for (unsigned I = 0; I < NumberedEncodings.size(); ++I) {
     const Record *EncodingDef = NumberedEncodings[I].EncodingDef;
     const CodeGenInstruction *Inst = NumberedEncodings[I].Inst;
     const Record *Def = Inst->TheDef;
     unsigned const Size = EncodingDef->getValueAsInt("Size");
     if (Def->getValueAsString("Namespace") == "TargetOpcode" ||
         Def->getValueAsBit("isPseudo") ||
         Def->getValueAsBit("isAsmParserOnly") ||
         Def->getValueAsBit("isCodeGenOnly")) {
-      NumEncodingsLackingDisasm++;
+      StatsNumEncodingsLackingDisasm++;
       continue;
     }
 
     if (I < NumberedInstructions.size())
-      NumInstructions++;
-    NumEncodings++;
+      StatsNumInstructions++;
+    StatsNumEncodings++;
 
     if (!Size && !IsVarLenInst)
       continue;
 
     if (IsVarLenInst)
       InstrLen.resize(NumberedInstructions.size(), 0);
 
     if (unsigned const Len = populateInstruction(Target, *EncodingDef, *Inst, I,
                                                  Operands, IsVarLenInst)) {
       if (IsVarLenInst) {
         MaxInstLen = std::max(MaxInstLen, Len);
         InstrLen[I] = Len;
       }
       std::string DecoderNamespace =
           std::string(EncodingDef->getValueAsString("DecoderNamespace"));
       if (!NumberedEncodings[I].HwModeName.empty())
         DecoderNamespace +=
             std::string("_") + NumberedEncodings[I].HwModeName.str();
       OpcMap[std::make_pair(DecoderNamespace, Size)].emplace_back(
           I, IndexOfInstruction.find(Def)->second);
     } else {
-      NumEncodingsOmitted++;
+      StatsNumEncodingsOmitted++;
     }
   }
   return MaxInstLen;
 }
 
 // Emits disassembler code for instruction decoding.
-void DecoderEmitter::run(raw_ostream &O) {
-  formatted_raw_ostream OS(O);
-  OS << "#include \"llvm/MC/MCInst.h\"\n";
-  OS << "#include \"llvm/MC/MCSubtargetInfo.h\"\n";
-  OS << "#include \"llvm/MC/SubtargetFeature.h\"\n";
-  OS << "#include \"llvm/Support/DataTypes.h\"\n";
-  OS << "#include \"llvm/Support/Debug.h\"\n";
-  OS << "#include \"llvm/Support/LEB128.h\"\n";
-  OS << "#include \"llvm/Support/raw_ostream.h\"\n";
-  OS << "#include <assert.h>\n";
-  OS << '\n';
-  OS << "namespace llvm {\n\n";
-
-  emitFieldFromInstruction(OS);
-  emitInsertBits(OS);
+void DecoderEmitter::run() {
+  PI.emitSourceFileHeader();
+  PI.emitIncludes();
+  PI.emitNamespaceBegin("llvm");
+  PI.emitFieldFromInstruction();
+  PI.emitInsertBits();
 
   Target.reverseBitsForLittleEndianEncoding();
 
   // Parameterize the decoders based on namespace and instruction width.
   NumberedInstructions = Target.getInstructionsByEnumValue();
   NumberedEncodings.reserve(NumberedInstructions.size());
 
   retrieveHwModeEncodings();
 
-  for (const auto &NumberedAlias : RK.getAllDerivedDefinitions("AdditionalEncoding"))
+  for (const auto &NumberedAlias :
+       RK.getAllDerivedDefinitions("AdditionalEncoding"))
     NumberedEncodings.emplace_back(
         NumberedAlias,
         &Target.getInstruction(NumberedAlias->getValueAsDef("AliasOf")));
 
   bool const IsVarLenInst =
       any_of(NumberedInstructions, [](const CodeGenInstruction *CGI) {
         RecordVal *RV = CGI->TheDef->getValue("Inst");
         return RV && isa<DagInit>(RV->getValue());
       });
 
   unsigned const MaxInstLen = fillOpcMap(IsVarLenInst);
 
   // Build the state machine for instruction decoding.
   DecoderTableInfo TableInfo;
   for (const auto &Opc : OpcMap) {
     // Emit the decoder for this namespace+width combination.
     ArrayRef<EncodingAndInst> const NumberedEncodingsRef(
         NumberedEncodings.data(), NumberedEncodings.size());
-    FilterChooser const FC(NumberedEncodingsRef, Opc.second, Operands,
-                     IsVarLenInst ? MaxInstLen : 8 * Opc.first.second, this);
+    FilterChooser const FC(PI, NumberedEncodingsRef, Opc.second, Operands,
+                           IsVarLenInst ? MaxInstLen : 8 * Opc.first.second);
 
     // The decode table is cleared for each top level decoder function. The
     // predicates and decoders themselves, however, are shared across all
     // decoders to give more opportunities for uniqueing.
     TableInfo.Table.clear();
     TableInfo.FixupStack.clear();
     TableInfo.Table.reserve(16384);
     TableInfo.FixupStack.emplace_back();
     FC.emitTableEntries(TableInfo);
     // Any NumToSkip fixups in the top level scope can resolve to the
     // OPC_Fail at the end of the table.
     assert(TableInfo.FixupStack.size() == 1 && "fixup stack phasing error!");
     // Resolve any NumToSkip fixups in the current scope.
     resolveTableFixups(TableInfo.Table, TableInfo.FixupStack.back(),
                        TableInfo.Table.size());
     TableInfo.FixupStack.clear();
 
     TableInfo.Table.push_back(MCD::OPC_Fail);
 
     // Print the table to the output stream.
-    emitTable(OS, TableInfo.Table, 0, FC.getBitWidth(), Opc.first.first);
-    OS.flush();
+    PI.emitTable(TableInfo.Table, FC.getBitWidth(), Opc.first.first,
+                 NumberedEncodings);
+    PI.flushOS();
   }
 
   // For variable instruction, we emit a instruction length table
   // to let the decoder know how long the instructions are.
   // You can see example usage in M68k's disassembler.
   if (IsVarLenInst)
-    emitInstrLenTable(OS, InstrLen);
+    PI.emitInstrLenTable(InstrLen);
   // Emit the predicate function.
-  emitPredicateFunction(OS, TableInfo.Predicates, 0);
+  PI.emitPredicateFunction(TableInfo.Predicates, 0);
 
   // Emit the decoder function.
-  emitDecoderFunction(OS, TableInfo.Decoders, 0);
+  PI.emitDecoderFunction(TableInfo.Decoders, 0);
 
   // Emit the main entry point for the decoder, decodeInstruction().
-  emitDecodeInstruction(OS, IsVarLenInst);
-
-  OS << "\n} // end namespace llvm\n";
+  PI.emitDecodeInstruction(IsVarLenInst);
+  PI.emitNamespaceEnd("llvm");
 }
 } // end namespace tblgen_decoder_emitter
 
+namespace {
+static void setPrinterParameters(CodeGenTarget &Target, ActionType Action,
+                                 std::string &PredicateNamespace,
+                                 std::string &GPrefix, std::string &GPostfix,
+                                 std::string &ROK, std::string &RFail,
+                                 std::string &L) {
+  // ARM and Thumb have a CHECK() macro to deal with DecodeStatuses.
+  if (Target.getName() == "ARM" || Target.getName() == "Thumb" ||
+      Target.getName() == "AArch64" || Target.getName() == "ARM64") {
+    PredicateNamespace = std::string(Target.getName());
+
+    if (PredicateNamespace == "Thumb")
+      PredicateNamespace = "ARM";
+
+    switch (Action) {
+    default:
+      GPrefix = "if (!Check(S, ";
+      L = "  MCDisassembler::DecodeStatus S = "
+          "MCDisassembler::Success;\n(void)S;";
+      break;
+    case GenCapstone:
+      GPrefix = "if (!Check(&S, ";
+      L = "  MCDisassembler_DecodeStatus S = MCDisassembler_Success;\n(void)S;";
+      break;
+    }
+    GPostfix = "))";
+  } else {
+    PredicateNamespace = Target.getName().str();
+    GPrefix = "if (";
+    GPostfix = " == MCDisassembler::Fail)";
+    L = "";
+  }
+
+  ROK = "S";
+
+  switch (Action) {
+  default:
+    RFail = "MCDisassembler::Fail";
+    break;
+  case GenCapstone:
+    RFail = "MCDisassembler_Fail";
+    break;
+  }
+}
+} // namespace
+
 namespace llvm {
 
-void EmitDecoder(RecordKeeper &RK, raw_ostream &OS,
-                 const std::string &PredicateNamespace,
-                 const std::string &GPrefix, const std::string &GPostfix,
-                 const std::string &ROK, const std::string &RFail,
-                 const std::string &L) {
-  tblgen_decoder_emitter::DecoderEmitter(RK, PredicateNamespace, GPrefix, GPostfix, ROK, RFail, L)
-      .run(OS);
+void EmitDecoder(RecordKeeper &RK, raw_ostream &OS, CodeGenTarget &Target,
+                 ActionType Action) {
+  formatted_raw_ostream FOS(OS);
+  tblgen_decoder_emitter::PrinterInterface *PI;
+  std::string PredicateNamespace;
+  std::string GPrefix;
+  std::string GPostfix;
+  std::string ROK;
+  std::string RFail;
+  std::string L;
+
+  setPrinterParameters(Target, Action, PredicateNamespace, GPrefix, GPostfix,
+                       ROK, RFail, L);
+
+  if (Action == GenCapstone) {
+    PI = new tblgen_decoder_emitter::PrinterCapstone(
+        FOS, PredicateNamespace, GPrefix, GPostfix, ROK, RFail, L,
+        Target.getName().str());
+  } else {
+    PI = new tblgen_decoder_emitter::PrinterLLVM(FOS, PredicateNamespace,
+                                                 GPrefix, GPostfix, ROK, RFail,
+                                                 L, Target.getName().str());
   }
+  tblgen_decoder_emitter::DecoderEmitter(RK, *PI).run();
 
-} // end namespace llvm
+  delete PI;
+}
 
+} // end namespace llvm

llvm/utils/TableGen/DecoderEmitter/DecoderEmitterTypes.h

+//===------- DecoderEmitterTypes.h - Decoder Generator ----------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_UTILS_TABLEGEN_DECODEREMITTER_DECODEREMITTERTYPES_H
+#define LLVM_UTILS_TABLEGEN_DECODEREMITTER_DECODEREMITTERTYPES_H
+
+#include "../CodeGenInstruction.h"
+#include "../CodeGenTarget.h"
+#include "../InfoByHwMode.h"
+#include "../VarLenCodeEmitterGen.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/CachedHashString.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/MC/MCDecoderOps.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/LEB128.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+using namespace llvm;
+
+namespace tblgen_decoder_emitter {
+
+//////////////////////
+// Structs and Types
+//////////////////////
+
+struct EncodingField {
+  unsigned Base, Width, Offset;
+  EncodingField(unsigned B, unsigned W, unsigned O)
+      : Base(B), Width(W), Offset(O) {}
+};
+
+struct OperandInfo {
+  std::vector<EncodingField> Fields;
+  std::string Decoder;
+  bool HasCompleteDecoder;
+  uint64_t InitValue;
+
+  OperandInfo(std::string D, bool HCD)
+      : Decoder(std::move(D)), HasCompleteDecoder(HCD), InitValue(0) {}
+
+  void addField(unsigned Base, unsigned Width, unsigned Offset) {
+    Fields.push_back(EncodingField(Base, Width, Offset));
+  }
+
+  unsigned numFields() const { return Fields.size(); }
+
+  typedef std::vector<EncodingField>::const_iterator const_iterator;
+
+  const_iterator begin() const { return Fields.begin(); }
+  const_iterator end() const { return Fields.end(); }
+};
+
+typedef std::vector<uint8_t> DecoderTable;
+typedef uint32_t DecoderFixup;
+typedef std::vector<DecoderFixup> FixupList;
+typedef std::vector<FixupList> FixupScopeList;
+typedef SmallSetVector<CachedHashString, 16> PredicateSet;
+typedef SmallSetVector<CachedHashString, 16> DecoderSet;
+struct DecoderTableInfo {
+  DecoderTable Table;
+  FixupScopeList FixupStack;
+  PredicateSet Predicates;
+  DecoderSet Decoders;
+};
+
+struct EncodingAndInst {
+  const Record *EncodingDef;
+  const CodeGenInstruction *Inst;
+  StringRef HwModeName;
+
+  EncodingAndInst(const Record *EncodingDef, const CodeGenInstruction *Inst,
+                  StringRef HwModeName = "")
+      : EncodingDef(EncodingDef), Inst(Inst), HwModeName(HwModeName) {}
+};
+
+struct EncodingIDAndOpcode {
+  unsigned EncodingID;
+  unsigned Opcode;
+
+  EncodingIDAndOpcode() : EncodingID(0), Opcode(0) {}
+  EncodingIDAndOpcode(unsigned EncodingID, unsigned Opcode)
+      : EncodingID(EncodingID), Opcode(Opcode) {}
+};
+
+inline raw_ostream &operator<<(raw_ostream &OS, const EncodingAndInst &Value) {
+  if (Value.EncodingDef != Value.Inst->TheDef)
+    OS << Value.EncodingDef->getName() << ":";
+  OS << Value.Inst->TheDef->getName();
+  return OS;
+}
+
+// The set (BIT_TRUE, BIT_FALSE, BIT_UNSET) represents a ternary logic system
+// for a bit value.
+//
+// BIT_UNFILTERED is used as the init value for a filter position.  It is used
+// only for filter processings.
+typedef enum {
+  BIT_TRUE,      // '1'
+  BIT_FALSE,     // '0'
+  BIT_UNSET,     // '?'
+  BIT_UNFILTERED // unfiltered
+} bit_value_t;
+
+// Representation of the instruction to work on.
+typedef std::vector<bit_value_t> insn_t;
+
+// These are states of our finite state machines used in FilterChooser's
+// filterProcessor() which produces the filter candidates to use.
+typedef enum {
+  ATTR_NONE,
+  ATTR_FILTERED,
+  ATTR_ALL_SET,
+  ATTR_ALL_UNSET,
+  ATTR_MIXED
+} bitAttr_t;
+
+static const uint64_t NoFixedSegmentsSentinel = -1ULL;
+
+} // end namespace tblgen_decoder_emitter
+
+#endif // LLVM_UTILS_TABLEGEN_DECODEREMITTER_DECODEREMITTERTYPES_H

llvm/utils/TableGen/DecoderEmitter/Filter.cpp

 #include "DecoderEmitter.h"
 
 using namespace llvm;
 
 namespace tblgen_decoder_emitter {
 
 Filter::Filter(Filter &&F)
     : Owner(F.Owner), StartBit(F.StartBit), NumBits(F.NumBits), Mixed(F.Mixed),
-      FilteredInstructions(std::move(F.FilteredInstructions)),
-      VariableInstructions(std::move(F.VariableInstructions)),
+      FilteredInstrSubsets(std::move(F.FilteredInstrSubsets)),
+      VariableInstrSubset(std::move(F.VariableInstrSubset)),
       FilterChooserMap(std::move(F.FilterChooserMap)),
       NumFiltered(F.NumFiltered), LastOpcFiltered(F.LastOpcFiltered) {}
 
 Filter::Filter(FilterChooser &Owner, unsigned StartBit, unsigned NumBits,
                bool Mixed)
     : Owner(&Owner), StartBit(StartBit), NumBits(NumBits), Mixed(Mixed) {
   assert(StartBit + NumBits - 1 < Owner.BitWidth);
 
for (unsigned I = 0, E = Owner.Opcodes.size(); I != E; ++I) {
     uint64_t Field;
     // Scans the segment for possibly well-specified encoding bits.
     bool const Ok = Owner.fieldFromInsn(Field, Insn, StartBit, NumBits);
 
     if (Ok) {
       // The encoding bits are well-known.  Lets add the uid of the
       // instruction into the bucket keyed off the constant field value.
       LastOpcFiltered = Owner.Opcodes[I];
-      FilteredInstructions[Field].push_back(LastOpcFiltered);
+      FilteredInstrSubsets[Field].push_back(LastOpcFiltered);
       ++NumFiltered;
     } else {
       // Some of the encoding bit(s) are unspecified.  This contributes to
       // one additional member of "Variable" instructions.
-      VariableInstructions.push_back(Owner.Opcodes[I]);
+      VariableInstrSubset.push_back(Owner.Opcodes[I]);
     }
   }
 
-  assert((FilteredInstructions.size() + VariableInstructions.size() > 0) &&
-         "Filter returns no instruction categories");
+  assert((FilteredInstrSubsets.size() + VariableInstrSubset.size() > 0) &&
+         "Filter returns no instruction subsets.");
 }
 
 // Divides the decoding task into sub tasks and delegates them to the
 // inferior FilterChooser's.
 //
 // A special case arises when there's only one entry in the filtered
 // instructions.  In order to unambiguously decode the singleton, we need to
 // match the remaining undecoded encoding bits against the singleton.
 void Filter::recurse() {
   // Starts by inheriting our parent filter chooser's filter bit values.
   std::vector<bit_value_t> BitValueArray(Owner->FilterBitValues);
 
-  if (!VariableInstructions.empty()) {
+  if (!VariableInstrSubset.empty()) {
     // Conservatively marks each segment position as BIT_UNSET.
     for (unsigned BitIndex = 0; BitIndex < NumBits; ++BitIndex)
       BitValueArray[StartBit + BitIndex] = BIT_UNSET;
 
     // Delegates to an inferior filter chooser for further processing on this
     // group of instructions whose segment values are variable.
     FilterChooserMap.insert(std::make_pair(
         NoFixedSegmentsSentinel,
-        std::make_unique<FilterChooser>(Owner->AllInstructions,
-                                        VariableInstructions, Owner->Operands,
+        std::make_unique<FilterChooser>(Owner->PI, Owner->AllInstructions,
+                                        VariableInstrSubset, Owner->Operands,
                                         BitValueArray, *Owner)));
   }
 
   // No need to recurse for a singleton filtered instruction.
   // See also Filter::emit*().
   if (getNumFiltered() == 1) {
     assert(FilterChooserMap.size() == 1);
     return;
   }
 
   // Otherwise, create sub choosers.
-  for (const auto &Inst : FilteredInstructions) {
+  for (const auto &Subset : FilteredInstrSubsets) {
     // Marks all the segment positions with either BIT_TRUE or BIT_FALSE.
     for (unsigned BitIndex = 0; BitIndex < NumBits; ++BitIndex) {
-      if (Inst.first & (1ULL << BitIndex))
+      if (Subset.first & (1ULL << BitIndex))
         BitValueArray[StartBit + BitIndex] = BIT_TRUE;
       else
         BitValueArray[StartBit + BitIndex] = BIT_FALSE;
     }
 
     // Delegates to an inferior filter chooser for further processing on this
-    // category of instructions.
+    // subset of instructions.
     FilterChooserMap.insert(std::make_pair(
-        Inst.first, std::make_unique<FilterChooser>(
-                        Owner->AllInstructions, Inst.second, Owner->Operands,
-                        BitValueArray, *Owner)));
+        Subset.first, std::make_unique<FilterChooser>(
+                          Owner->PI, Owner->AllInstructions, Subset.second,
+                          Owner->Operands, BitValueArray, *Owner)));
   }
 }
 
 // Emit table entries to decode instructions given a segment or segments
 // of bits.
 void Filter::emitTableEntry(DecoderTableInfo &TableInfo) const {
   TableInfo.Table.push_back(MCD::OPC_ExtractField);
   TableInfo.Table.push_back(StartBit);
void Filter::emitTableEntry(DecoderTableInfo &TableInfo) const {
 
   // If there is no fallthrough, then the final filter should get fixed
   // up according to the enclosing scope rather than the current position.
   if (!HasFallthrough)
     TableInfo.FixupStack.back().push_back(PrevFilter);
 }
 
 // Returns the number of fanout produced by the filter.  More fanout implies
-// the filter distinguishes more categories of instructions.
+// the filter distinguishes more subsets of instructions.
 unsigned Filter::usefulness() const {
-  if (!VariableInstructions.empty())
-    return FilteredInstructions.size();
-  return FilteredInstructions.size() + 1;
+  if (!VariableInstrSubset.empty())
+    return FilteredInstrSubsets.size();
+  return FilteredInstrSubsets.size() + 1;
 }
 
 } // end namespace tblgen_decoder_emitter

llvm/utils/TableGen/DecoderEmitter/FilterChooser.cpp

 
 #include "DecoderEmitter.h"
 
 using namespace llvm;
 
 namespace tblgen_decoder_emitter {
 
 #define DEBUG_TYPE "decoder-emitter-FilterChooser"
-STATISTIC(NumEncodingsSupported, "Number of encodings supported");
+STATISTIC(StatsNumEncodingsSupported, "Number of encodings supported");
 
 // Populates the insn given the uid.
 void FilterChooser::insnWithID(insn_t &Insn, unsigned Opcode) const {
   BitsInit const &Bits =
       getBitsField(*AllInstructions[Opcode].EncodingDef, "Inst");
   Insn.resize(BitWidth > Bits.getNumBits() ? BitWidth : Bits.getNumBits(),
               BIT_UNSET);
   // We may have a SoftFail bitmask, which specifies a mask where an encoding
if (State == 2) {
     ++Num;
   }
 
   assert(StartBits.size() == Num && EndBits.size() == Num &&
          FieldVals.size() == Num);
   return Num;
 }
 
-void FilterChooser::emitBinaryParser(raw_ostream &O, unsigned &Indentation,
-                                     const OperandInfo &OpInfo,
-                                     bool &OpHasCompleteDecoder) const {
-  const std::string &Decoder = OpInfo.Decoder;
-
-  bool const UseInsertBits = OpInfo.numFields() != 1 || OpInfo.InitValue != 0;
-
-  if (UseInsertBits) {
-    O.indent(Indentation) << "tmp = 0x";
-    O.write_hex(OpInfo.InitValue);
-    O << ";\n";
-  }
-
-  for (const EncodingField &EF : OpInfo) {
-    O.indent(Indentation);
-    if (UseInsertBits)
-      O << "insertBits(tmp, ";
-    else
-      O << "tmp = ";
-    O << "fieldFromInstruction(insn, " << EF.Base << ", " << EF.Width << ')';
-    if (UseInsertBits)
-      O << ", " << EF.Offset << ", " << EF.Width << ')';
-    else if (EF.Offset != 0)
-      O << " << " << EF.Offset;
-    O << ";\n";
-  }
-
-  if (Decoder != "") {
-    OpHasCompleteDecoder = OpInfo.HasCompleteDecoder;
-    O.indent(Indentation) << Emitter->GuardPrefix << Decoder
-                          << "(MI, tmp, Address, Decoder)"
-                          << Emitter->GuardPostfix << " { "
-                          << (OpHasCompleteDecoder ? ""
-                                                   : "DecodeComplete = false; ")
-                          << "return MCDisassembler::Fail; }\n";
-  } else {
-    OpHasCompleteDecoder = true;
-    O.indent(Indentation) << "MI.addOperand(MCOperand::createImm(tmp));\n";
-  }
-}
-
-void FilterChooser::emitDecoder(raw_ostream &OS, unsigned Indentation,
-                                unsigned Opc, bool &HasCompleteDecoder) const {
+void FilterChooser::emitDecoder(raw_ostream &DecoderOS, unsigned Opc,
+                                bool &HasCompleteDecoder) const {
   HasCompleteDecoder = true;
 
   for (const auto &Op : Operands.find(Opc)->second) {
     // If a custom instruction decoder was specified, use that.
     if (Op.numFields() == 0 && !Op.Decoder.empty()) {
       HasCompleteDecoder = Op.HasCompleteDecoder;
-      OS.indent(Indentation)
-          << Emitter->GuardPrefix << Op.Decoder
-          << "(MI, insn, Address, Decoder)" << Emitter->GuardPostfix << " { "
-          << (HasCompleteDecoder ? "" : "DecodeComplete = false; ")
-          << "return MCDisassembler::Fail; }\n";
+      PI.emitOpDecoder(DecoderOS, Op);
       break;
     }
 
-    bool OpHasCompleteDecoder;
-    emitBinaryParser(OS, Indentation, Op, OpHasCompleteDecoder);
-    if (!OpHasCompleteDecoder)
-      HasCompleteDecoder = false;
+    PI.emitOpBinaryParser(DecoderOS, Op);
+
+    // If a custom decoder was set the flag decides otherwise its true.
+    HasCompleteDecoder = Op.Decoder != "" ? Op.HasCompleteDecoder : true;
   }
 }
 
 unsigned FilterChooser::getDecoderIndex(DecoderSet &Decoders, unsigned Opc,
                                         bool &HasCompleteDecoder) const {
   // Build up the predicate string.
   SmallString<256> Decoder;
   // FIXME: emitDecoder() function can take a buffer directly rather than
   // a stream.
   raw_svector_ostream S(Decoder);
-  unsigned const I = 4;
-  emitDecoder(S, I, Opc, HasCompleteDecoder);
+  emitDecoder(S, Opc, HasCompleteDecoder);
 
   // Using the full decoder string as the key value here is a bit
   // heavyweight, but is effective. If the string comparisons become a
   // performance concern, we can implement a mangling of the predicate
   // data easily enough with a map back to the actual string. That's
   // overkill for now, though.
 
   // Make sure the predicate is in the table.
   Decoders.insert(CachedHashString(Decoder));
   // Now figure out the index for when we write out the table.
   DecoderSet::const_iterator P = find(Decoders, Decoder.str());
   return (unsigned)(P - Decoders.begin());
 }
 
-// If ParenIfBinOp is true, print a surrounding () if Val uses && or ||.
-bool FilterChooser::emitPredicateMatchAux(const Init &Val, bool ParenIfBinOp,
-                                          raw_ostream &OS) const {
-  if (auto *D = dyn_cast<DefInit>(&Val)) {
-    if (!D->getDef()->isSubClassOf("SubtargetFeature"))
-      return true;
-    OS << "Bits[" << Emitter->PredicateNamespace << "::" << D->getAsString()
-       << "]";
-    return false;
-  }
-  if (auto *D = dyn_cast<DagInit>(&Val)) {
-    std::string const Op = D->getOperator()->getAsString();
-    if (Op == "not" && D->getNumArgs() == 1) {
-      OS << '!';
-      return emitPredicateMatchAux(*D->getArg(0), true, OS);
-    }
-    if ((Op == "any_of" || Op == "all_of") && D->getNumArgs() > 0) {
-      bool const Paren =
-          D->getNumArgs() > 1 && std::exchange(ParenIfBinOp, true);
-      if (Paren)
-        OS << '(';
-      ListSeparator LS(Op == "any_of" ? " || " : " && ");
-      for (auto *Arg : D->getArgs()) {
-        OS << LS;
-        if (emitPredicateMatchAux(*Arg, ParenIfBinOp, OS))
-          return true;
-      }
-      if (Paren)
-        OS << ')';
-      return false;
-    }
-  }
-  return true;
-}
-
-bool FilterChooser::emitPredicateMatch(raw_ostream &O, unsigned &Indentation,
-                                       unsigned Opc) const {
-  ListInit *Predicates =
-      AllInstructions[Opc].EncodingDef->getValueAsListInit("Predicates");
-  bool IsFirstEmission = true;
-  for (unsigned I = 0; I < Predicates->size(); ++I) {
-    Record *Pred = Predicates->getElementAsRecord(I);
-    if (!Pred->getValue("AssemblerMatcherPredicate"))
-      continue;
-
-    if (!isa<DagInit>(Pred->getValue("AssemblerCondDag")->getValue()))
-      continue;
-
-    if (!IsFirstEmission)
-      O << " && ";
-    if (emitPredicateMatchAux(*Pred->getValueAsDag("AssemblerCondDag"),
-                              Predicates->size() > 1, O))
-      PrintFatalError(Pred->getLoc(), "Invalid AssemblerCondDag!");
-    IsFirstEmission = false;
-  }
-  return !Predicates->empty();
-}
-
 bool FilterChooser::doesOpcodeNeedPredicate(unsigned Opc) const {
   ListInit *Predicates =
       AllInstructions[Opc].EncodingDef->getValueAsListInit("Predicates");
   for (unsigned I = 0; I < Predicates->size(); ++I) {
     Record *Pred = Predicates->getElementAsRecord(I);
     if (!Pred->getValue("AssemblerMatcherPredicate"))
       continue;
 

 
 void FilterChooser::emitPredicateTableEntry(DecoderTableInfo &TableInfo,
                                             unsigned Opc) const {
   if (!doesOpcodeNeedPredicate(Opc))
     return;
 
   // Build up the predicate string.
   SmallString<256> Predicate;
-  // FIXME: emitPredicateMatch() functions can take a buffer directly rather
-  // than a stream.
   raw_svector_ostream PS(Predicate);
-  unsigned I = 0;
-  emitPredicateMatch(PS, I, Opc);
+  const ListInit *Predicates =
+      AllInstructions[Opc].EncodingDef->getValueAsListInit("Predicates");
+  PI.emitPredicateMatch(PS, Predicates, Opc);
 
   // Figure out the index into the predicate table for the predicate just
   // computed.
   unsigned const PIdx = getPredicateIndex(TableInfo, PS.str());
   SmallString<16> PBytes;
   raw_svector_ostream S(PBytes);
   encodeULEB128(PIdx, S);
 
void FilterChooser::emitSingletonTableEntry(DecoderTableInfo &TableInfo,
   // and for any value can determine if the bitpattern is a valid instruction
   // or not. This means OPC_Decode will be the final step in the decoding
   // process. If it is not complete, then the Fail return code from the
   // decoder method indicates that additional processing should be done to see
   // if there is any other instruction that also matches the bitpattern and
   // can decode it.
   TableInfo.Table.push_back(HasCompleteDecoder ? MCD::OPC_Decode
                                                : MCD::OPC_TryDecode);
-  NumEncodingsSupported++;
+  StatsNumEncodingsSupported++;
   uint8_t Buffer[16], *P;
   encodeULEB128(Opc.Opcode, Buffer);
   for (P = Buffer; *P >= 128; ++P)
     TableInfo.Table.push_back(*P);
   TableInfo.Table.push_back(*P);
 
   SmallString<16> Bytes;
   raw_svector_ostream S(Bytes);

llvm/utils/TableGen/DecoderEmitter/HelperFunctions.cpp

LLVM_DEBUG({
 
         errs() << "\t" << OperandName << " (" << OperandDef.getName() << ")\n";
       }
     });
 #endif
 
   return Bits.getNumBits();
 }
-
-// emitFieldFromInstruction - Emit the templated helper function
-// fieldFromInstruction().
-// On Windows we make sure that this function is not inlined when
-// using the VS compiler. It has a bug which causes the function
-// to be optimized out in some circustances. See llvm.org/pr38292
-void emitFieldFromInstruction(formatted_raw_ostream &OS) {
-  OS << "// Helper functions for extracting fields from encoded instructions.\n"
-     << "// InsnType must either be integral or an APInt-like object that "
-        "must:\n"
-     << "// * be default-constructible and copy-constructible\n"
-     << "// * be constructible from an APInt (this can be private)\n"
-     << "// * Support insertBits(bits, startBit, numBits)\n"
-     << "// * Support extractBitsAsZExtValue(numBits, startBit)\n"
-     << "// * Support the ~, &, ==, and != operators with other objects of "
-        "the same type\n"
-     << "// * Support the != and bitwise & with uint64_t\n"
-     << "// * Support put (<<) to raw_ostream&\n"
-     << "template <typename InsnType>\n"
-     << "#if defined(_MSC_VER) && !defined(__clang__)\n"
-     << "__declspec(noinline)\n"
-     << "#endif\n"
-     << "static std::enable_if_t<std::is_integral<InsnType>::value, InsnType>\n"
-     << "fieldFromInstruction(const InsnType &insn, unsigned startBit,\n"
-     << "                     unsigned numBits) {\n"
-     << "  assert(startBit + numBits <= 64 && \"Cannot support >64-bit "
-        "extractions!\");\n"
-     << "  assert(startBit + numBits <= (sizeof(InsnType) * 8) &&\n"
-     << "         \"Instruction field out of bounds!\");\n"
-     << "  InsnType fieldMask;\n"
-     << "  if (numBits == sizeof(InsnType) * 8)\n"
-     << "    fieldMask = (InsnType)(-1LL);\n"
-     << "  else\n"
-     << "    fieldMask = (((InsnType)1 << numBits) - 1) << startBit;\n"
-     << "  return (insn & fieldMask) >> startBit;\n"
-     << "}\n"
-     << "\n"
-     << "template <typename InsnType>\n"
-     << "static std::enable_if_t<!std::is_integral<InsnType>::value, "
-        "uint64_t>\n"
-     << "fieldFromInstruction(const InsnType &insn, unsigned startBit,\n"
-     << "                     unsigned numBits) {\n"
-     << "  return insn.extractBitsAsZExtValue(numBits, startBit);\n"
-     << "}\n\n";
-}
-
-// emitInsertBits - Emit the templated helper function insertBits().
-void emitInsertBits(formatted_raw_ostream &OS) {
-  OS << "// Helper function for inserting bits extracted from an encoded "
-        "instruction into\n"
-     << "// a field.\n"
-     << "template <typename InsnType>\n"
-     << "static std::enable_if_t<std::is_integral<InsnType>::value>\n"
-     << "insertBits(InsnType &field, InsnType bits, unsigned startBit, "
-        "unsigned numBits) {\n"
-     << "  assert(startBit + numBits <= sizeof field * 8);\n"
-     << "  field |= (InsnType)bits << startBit;\n"
-     << "}\n"
-     << "\n"
-     << "template <typename InsnType>\n"
-     << "static std::enable_if_t<!std::is_integral<InsnType>::value>\n"
-     << "insertBits(InsnType &field, uint64_t bits, unsigned startBit, "
-        "unsigned numBits) {\n"
-     << "  field.insertBits(bits, startBit, numBits);\n"
-     << "}\n\n";
-}
-
-// emitDecodeInstruction - Emit the templated helper function
-// decodeInstruction().
-void emitDecodeInstruction(formatted_raw_ostream &OS, bool IsVarLenInst) {
-  OS << "template <typename InsnType>\n"
-     << "static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], "
-        "MCInst &MI,\n"
-     << "                                      InsnType insn, uint64_t "
-        "Address,\n"
-     << "                                      const MCDisassembler *DisAsm,\n"
-     << "                                      const MCSubtargetInfo &STI";
-  if (IsVarLenInst) {
-    OS << ",\n"
-       << "                                      llvm::function_ref<void(APInt "
-          "&,"
-       << " uint64_t)> makeUp";
-  }
-  OS << ") {\n"
-     << "  const FeatureBitset &Bits = STI.getFeatureBits();\n"
-     << "\n"
-     << "  const uint8_t *Ptr = DecodeTable;\n"
-     << "  uint64_t CurFieldValue = 0;\n"
-     << "  DecodeStatus S = MCDisassembler::Success;\n"
-     << "  while (true) {\n"
-     << "    ptrdiff_t Loc = Ptr - DecodeTable;\n"
-     << "    switch (*Ptr) {\n"
-     << "    default:\n"
-     << "      errs() << Loc << \": Unexpected decode table opcode!\\n\";\n"
-     << "      return MCDisassembler::Fail;\n"
-     << "    case MCD::OPC_ExtractField: {\n"
-     << "      unsigned Start = *++Ptr;\n"
-     << "      unsigned Len = *++Ptr;\n"
-     << "      ++Ptr;\n";
-  if (IsVarLenInst)
-    OS << "      makeUp(insn, Start + Len);\n";
-  OS << "      CurFieldValue = fieldFromInstruction(insn, Start, Len);\n"
-     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_ExtractField(\" << Start << "
-        "\", \"\n"
-     << "                   << Len << \"): \" << CurFieldValue << \"\\n\");\n"
-     << "      break;\n"
-     << "    }\n"
-     << "    case MCD::OPC_FilterValue: {\n"
-     << "      // Decode the field value.\n"
-     << "      unsigned Len;\n"
-     << "      uint64_t Val = decodeULEB128(++Ptr, &Len);\n"
-     << "      Ptr += Len;\n"
-     << "      // NumToSkip is a plain 24-bit integer.\n"
-     << "      unsigned NumToSkip = *Ptr++;\n"
-     << "      NumToSkip |= (*Ptr++) << 8;\n"
-     << "      NumToSkip |= (*Ptr++) << 16;\n"
-     << "\n"
-     << "      // Perform the filter operation.\n"
-     << "      if (Val != CurFieldValue)\n"
-     << "        Ptr += NumToSkip;\n"
-     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_FilterValue(\" << Val << "
-        "\", \" << NumToSkip\n"
-     << "                   << \"): \" << ((Val != CurFieldValue) ? \"FAIL:\" "
-        ": \"PASS:\")\n"
-     << "                   << \" continuing at \" << (Ptr - DecodeTable) << "
-        "\"\\n\");\n"
-     << "\n"
-     << "      break;\n"
-     << "    }\n"
-     << "    case MCD::OPC_CheckField: {\n"
-     << "      unsigned Start = *++Ptr;\n"
-     << "      unsigned Len = *++Ptr;\n";
-  if (IsVarLenInst)
-    OS << "      makeUp(insn, Start + Len);\n";
-  OS << "      uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);\n"
-     << "      // Decode the field value.\n"
-     << "      unsigned PtrLen = 0;\n"
-     << "      uint64_t ExpectedValue = decodeULEB128(++Ptr, &PtrLen);\n"
-     << "      Ptr += PtrLen;\n"
-     << "      // NumToSkip is a plain 24-bit integer.\n"
-     << "      unsigned NumToSkip = *Ptr++;\n"
-     << "      NumToSkip |= (*Ptr++) << 8;\n"
-     << "      NumToSkip |= (*Ptr++) << 16;\n"
-     << "\n"
-     << "      // If the actual and expected values don't match, skip.\n"
-     << "      if (ExpectedValue != FieldValue)\n"
-     << "        Ptr += NumToSkip;\n"
-     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_CheckField(\" << Start << "
-        "\", \"\n"
-     << "                   << Len << \", \" << ExpectedValue << \", \" << "
-        "NumToSkip\n"
-     << "                   << \"): FieldValue = \" << FieldValue << \", "
-        "ExpectedValue = \"\n"
-     << "                   << ExpectedValue << \": \"\n"
-     << "                   << ((ExpectedValue == FieldValue) ? \"PASS\\n\" : "
-        "\"FAIL\\n\"));\n"
-     << "      break;\n"
-     << "    }\n"
-     << "    case MCD::OPC_CheckPredicate: {\n"
-     << "      unsigned Len;\n"
-     << "      // Decode the Predicate Index value.\n"
-     << "      unsigned PIdx = decodeULEB128(++Ptr, &Len);\n"
-     << "      Ptr += Len;\n"
-     << "      // NumToSkip is a plain 24-bit integer.\n"
-     << "      unsigned NumToSkip = *Ptr++;\n"
-     << "      NumToSkip |= (*Ptr++) << 8;\n"
-     << "      NumToSkip |= (*Ptr++) << 16;\n"
-     << "      // Check the predicate.\n"
-     << "      bool Pred;\n"
-     << "      if (!(Pred = checkDecoderPredicate(PIdx, Bits)))\n"
-     << "        Ptr += NumToSkip;\n"
-     << "      (void)Pred;\n"
-     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_CheckPredicate(\" << PIdx "
-        "<< \"): \"\n"
-     << "            << (Pred ? \"PASS\\n\" : \"FAIL\\n\"));\n"
-     << "\n"
-     << "      break;\n"
-     << "    }\n"
-     << "    case MCD::OPC_Decode: {\n"
-     << "      unsigned Len;\n"
-     << "      // Decode the Opcode value.\n"
-     << "      unsigned Opc = decodeULEB128(++Ptr, &Len);\n"
-     << "      Ptr += Len;\n"
-     << "      unsigned DecodeIdx = decodeULEB128(Ptr, &Len);\n"
-     << "      Ptr += Len;\n"
-     << "\n"
-     << "      MI.clear();\n"
-     << "      MI.setOpcode(Opc);\n"
-     << "      bool DecodeComplete;\n";
-  if (IsVarLenInst) {
-    OS << "      Len = InstrLenTable[Opc];\n"
-       << "      makeUp(insn, Len);\n";
-  }
-  OS << "      S = decodeToMCInst(S, DecodeIdx, insn, MI, Address, DisAsm, "
-        "DecodeComplete);\n"
-     << "      assert(DecodeComplete);\n"
-     << "\n"
-     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_Decode: opcode \" << Opc\n"
-     << "                   << \", using decoder \" << DecodeIdx << \": \"\n"
-     << "                   << (S != MCDisassembler::Fail ? \"PASS\" : "
-        "\"FAIL\") << \"\\n\");\n"
-     << "      return S;\n"
-     << "    }\n"
-     << "    case MCD::OPC_TryDecode: {\n"
-     << "      unsigned Len;\n"
-     << "      // Decode the Opcode value.\n"
-     << "      unsigned Opc = decodeULEB128(++Ptr, &Len);\n"
-     << "      Ptr += Len;\n"
-     << "      unsigned DecodeIdx = decodeULEB128(Ptr, &Len);\n"
-     << "      Ptr += Len;\n"
-     << "      // NumToSkip is a plain 24-bit integer.\n"
-     << "      unsigned NumToSkip = *Ptr++;\n"
-     << "      NumToSkip |= (*Ptr++) << 8;\n"
-     << "      NumToSkip |= (*Ptr++) << 16;\n"
-     << "\n"
-     << "      // Perform the decode operation.\n"
-     << "      MCInst TmpMI;\n"
-     << "      TmpMI.setOpcode(Opc);\n"
-     << "      bool DecodeComplete;\n"
-     << "      S = decodeToMCInst(S, DecodeIdx, insn, TmpMI, Address, DisAsm, "
-        "DecodeComplete);\n"
-     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_TryDecode: opcode \" << "
-        "Opc\n"
-     << "                   << \", using decoder \" << DecodeIdx << \": \");\n"
-     << "\n"
-     << "      if (DecodeComplete) {\n"
-     << "        // Decoding complete.\n"
-     << "        LLVM_DEBUG(dbgs() << (S != MCDisassembler::Fail ? \"PASS\" : "
-        "\"FAIL\") << \"\\n\");\n"
-     << "        MI = TmpMI;\n"
-     << "        return S;\n"
-     << "      } else {\n"
-     << "        assert(S == MCDisassembler::Fail);\n"
-     << "        // If the decoding was incomplete, skip.\n"
-     << "        Ptr += NumToSkip;\n"
-     << "        LLVM_DEBUG(dbgs() << \"FAIL: continuing at \" << (Ptr - "
-        "DecodeTable) << \"\\n\");\n"
-     << "        // Reset decode status. This also drops a SoftFail status "
-        "that could be\n"
-     << "        // set before the decode attempt.\n"
-     << "        S = MCDisassembler::Success;\n"
-     << "      }\n"
-     << "      break;\n"
-     << "    }\n"
-     << "    case MCD::OPC_SoftFail: {\n"
-     << "      // Decode the mask values.\n"
-     << "      unsigned Len;\n"
-     << "      uint64_t PositiveMask = decodeULEB128(++Ptr, &Len);\n"
-     << "      Ptr += Len;\n"
-     << "      uint64_t NegativeMask = decodeULEB128(Ptr, &Len);\n"
-     << "      Ptr += Len;\n"
-     << "      bool Fail = (insn & PositiveMask) != 0 || (~insn & "
-        "NegativeMask) != 0;\n"
-     << "      if (Fail)\n"
-     << "        S = MCDisassembler::SoftFail;\n"
-     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_SoftFail: \" << (Fail ? "
-        "\"FAIL\\n\" : \"PASS\\n\"));\n"
-     << "      break;\n"
-     << "    }\n"
-     << "    case MCD::OPC_Fail: {\n"
-     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_Fail\\n\");\n"
-     << "      return MCDisassembler::Fail;\n"
-     << "    }\n"
-     << "    }\n"
-     << "  }\n"
-     << "  llvm_unreachable(\"bogosity detected in disassembler state "
-        "machine!\");\n"
-     << "}\n\n";
-}
-
 } // end namespace tblgen_decoder_emitter

llvm/utils/TableGen/DecoderEmitter/Printer.h

+//===----------- PrinterInterface.h - Decoder Generator ---------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_UTILS_TABLEGEN_DECODEREMITTER_PRINTERINTERFACE_H
+#define LLVM_UTILS_TABLEGEN_DECODEREMITTER_PRINTERINTERFACE_H
+
+#include "DecoderEmitterTypes.h"
+#include "llvm/Support/ErrorHandling.h"
+
+using namespace llvm;
+namespace tblgen_decoder_emitter {
+
+/// Interface for printing the generated decoder.
+/// Every string which will be in the generated code originates from here.
+/// This class has methods for the FilterChooser class and the DecoderEmitter
+/// class.
+///
+/// The methods meant for the FilterChooser are used to generate the decoder
+/// source code. The strings for these decoders are directly written to the
+/// final out stream but assembled by the FilterChooser.
+///
+/// The methods for the DecoderEmitter exclusively write to the final output
+/// stream.
+class PrinterInterface {
+
+  friend class PrinterLLVM;
+  friend class PrinterCapstone;
+
+private:
+  formatted_raw_ostream &OS;
+  std::string TargetName;
+  std::string PredicateNamespace;
+  std::string GuardPrefix, GuardPostfix;
+  std::string ReturnOK, ReturnFail;
+  std::string Locals;
+
+public:
+  PrinterInterface(formatted_raw_ostream &OS, std::string PredicateNamespace,
+                   std::string GPrefix, std::string GPostfix, std::string ROK,
+                   std::string RFail, std::string L, std::string Target);
+
+  virtual ~PrinterInterface();
+
+  virtual void flushOS() const;
+
+  //
+  // FilterChooser printing
+  //
+
+  virtual void emitOpDecoder(raw_ostream &DecoderOS,
+                             const OperandInfo &Op) const = 0;
+  virtual void emitOpBinaryParser(raw_ostream &DecoderOS,
+                                  const OperandInfo &OpInfo) const = 0;
+  virtual bool emitPredicateMatchAux(const Init &Val, bool ParenIfBinOp,
+                                     raw_ostream &PredOS) const = 0;
+  // Emits code to check the Predicates member of an instruction are true.
+  // Returns true if predicate matches were emitted, false otherwise.
+  virtual bool emitPredicateMatch(raw_ostream &PredOS,
+                                  const ListInit *Predicates,
+                                  unsigned Opc) const = 0;
+
+  //
+  // DecoderEmitter printing
+  //
+  virtual void emitFieldFromInstruction() const = 0;
+  virtual void emitInsertBits() const = 0;
+  virtual void emitDecodeInstruction(bool IsVarLenInst) const = 0;
+  // Emit the decoder state machine table.
+  virtual void
+  emitTable(DecoderTable &Table, unsigned BitWidth, StringRef Namespace,
+            std::vector<EncodingAndInst> NumberedEncodings) const = 0;
+  virtual void emitInstrLenTable(std::vector<unsigned> &InstrLen) const = 0;
+  virtual void emitPredicateFunction(PredicateSet &Predicates,
+                                     unsigned Indentation) const = 0;
+  virtual void emitDecoderFunction(DecoderSet &Decoders,
+                                   unsigned Indentation) const = 0;
+  virtual void emitIncludes() const = 0;
+  virtual void emitNamespaceBegin(std::string const &Namespace) const = 0;
+  virtual void emitNamespaceEnd(std::string const &Namespace) const = 0;
+  virtual void emitSourceFileHeader() const = 0;
+};
+
+//
+// Printer Implementation classes
+//
+
+class PrinterLLVM : public PrinterInterface {
+public:
+  using PrinterInterface::PrinterInterface;
+
+  virtual void emitOpDecoder(raw_ostream &DecoderOS,
+                             const OperandInfo &Op) const override;
+  virtual void emitOpBinaryParser(raw_ostream &DecoderOS,
+                                  const OperandInfo &OpInfo) const override;
+  virtual bool emitPredicateMatchAux(const Init &Val, bool ParenIfBinOp,
+                                     raw_ostream &OS) const override;
+  virtual bool emitPredicateMatch(raw_ostream &PredOS,
+                                  const ListInit *Predicates,
+                                  unsigned Opc) const override;
+  virtual void emitFieldFromInstruction() const override;
+  virtual void emitInsertBits() const override;
+  virtual void emitDecodeInstruction(bool IsVarLenInst) const override;
+  virtual void
+  emitTable(DecoderTable &Table, unsigned BitWidth, StringRef Namespace,
+            std::vector<EncodingAndInst> NumberedEncodings) const override;
+  virtual void
+  emitInstrLenTable(std::vector<unsigned> &InstrLen) const override;
+  virtual void emitPredicateFunction(PredicateSet &Predicates,
+                                     unsigned Indentation) const override;
+  virtual void emitDecoderFunction(DecoderSet &Decoders,
+                                   unsigned Indentation) const override;
+  virtual void emitIncludes() const override;
+  virtual void emitNamespaceBegin(std::string const &Namespace) const override;
+  virtual void emitNamespaceEnd(std::string const &Namespace) const override;
+  virtual void emitSourceFileHeader() const override;
+};
+
+class PrinterCapstone : public PrinterInterface {
+public:
+  using PrinterInterface::PrinterInterface;
+
+  virtual void emitOpDecoder(raw_ostream &DecoderOS,
+                             const OperandInfo &Op) const override;
+  virtual void emitOpBinaryParser(raw_ostream &DecoderOS,
+                                  const OperandInfo &OpInfo) const override;
+  virtual bool emitPredicateMatchAux(const Init &Val, bool ParenIfBinOp,
+                                     raw_ostream &OS) const override;
+  virtual bool emitPredicateMatch(raw_ostream &PredOS,
+                                  const ListInit *Predicates,
+                                  unsigned Opc) const override;
+  virtual void emitFieldFromInstruction() const override;
+  virtual void emitInsertBits() const override;
+  virtual void emitDecodeInstruction(bool IsVarLenInst) const override;
+  virtual void
+  emitTable(DecoderTable &Table, unsigned BitWidth, StringRef Namespace,
+            std::vector<EncodingAndInst> NumberedEncodings) const override;
+  virtual void
+  emitInstrLenTable(std::vector<unsigned> &InstrLen) const override;
+  virtual void emitPredicateFunction(PredicateSet &Predicates,
+                                     unsigned Indentation) const override;
+  virtual void emitDecoderFunction(DecoderSet &Decoders,
+                                   unsigned Indentation) const override;
+  virtual void emitIncludes() const override;
+  virtual void emitNamespaceBegin(std::string const &Namespace) const override;
+  virtual void emitNamespaceEnd(std::string const &Namespace) const override;
+  virtual void emitSourceFileHeader() const override;
+};
+
+} // end namespace tblgen_decoder_emitter
+#endif // LLVM_UTILS_TABLEGEN_DECODEREMITTER_PRINTERINTERFACE_H

llvm/utils/TableGen/DecoderEmitter/PrinterCapstone.cpp

+//===------------- PrinterCapstone.cpp - Printer Capstone -------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Emits the generated decoder C++ code for the LLVM disassembler.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Printer.h"
+
+using namespace llvm;
+namespace tblgen_decoder_emitter {
+
+void PrinterCapstone::emitOpDecoder(raw_ostream &DecoderOS,
+                                    const OperandInfo &Op) const {
+  unsigned const Indent = 4;
+  DecoderOS.indent(Indent) << GuardPrefix << Op.Decoder
+                           << "(MI, insn, Address, Decoder)" << GuardPostfix
+                           << " { "
+                           << (Op.HasCompleteDecoder
+                                   ? ""
+                                   : "DecodeComplete = false; ")
+                           << "return " << ReturnFail << "; } \\\n";
+}
+
+void PrinterCapstone::emitOpBinaryParser(raw_ostream &DecOS,
+                                         const OperandInfo &OpInfo) const {
+  unsigned const Indent = 4;
+  const std::string &Decoder = OpInfo.Decoder;
+
+  bool const UseInsertBits = OpInfo.numFields() != 1 || OpInfo.InitValue != 0;
+
+  if (UseInsertBits) {
+    DecOS.indent(Indent) << "tmp = ";
+    DecOS.write_hex(OpInfo.InitValue);
+    DecOS << "; \\\n";
+  }
+
+  for (const EncodingField &EF : OpInfo) {
+    DecOS.indent(Indent);
+    if (UseInsertBits)
+      DecOS << "tmp |= ";
+    else
+      DecOS << "tmp = ";
+    DecOS << "fieldname(insn, " << EF.Base << ", " << EF.Width << ')';
+    if (UseInsertBits)
+      DecOS << " << " << EF.Offset;
+    else if (EF.Offset != 0)
+      DecOS << " << " << EF.Offset;
+    DecOS << "; \\\n";
+  }
+
+  if (Decoder != "") {
+    DecOS.indent(Indent) << GuardPrefix << Decoder
+                         << "(MI, tmp, Address, Decoder)" << GuardPostfix
+                         << " { "
+                         << (OpInfo.HasCompleteDecoder
+                                 ? ""
+                                 : "DecodeComplete = false; ")
+                         << "return " << ReturnFail << "; } \\\n";
+  } else {
+    DecOS.indent(Indent) << "MCOperand_CreateImm0(MI, tmp); \\\n";
+  }
+}
+
+bool PrinterCapstone::emitPredicateMatchAux(const Init &Val, bool ParenIfBinOp,
+                                            raw_ostream &PredOS) const {
+  if (auto *D = dyn_cast<DefInit>(&Val)) {
+    if (!D->getDef()->isSubClassOf("SubtargetFeature"))
+      return true;
+    PredOS << PredicateNamespace << "_getFeatureBits(MI->csh->mode, "
+           << PredicateNamespace << "_" << D->getAsString() << ")";
+    return false;
+  }
+  if (auto *D = dyn_cast<DagInit>(&Val)) {
+    std::string const Op = D->getOperator()->getAsString();
+    if (Op == "not" && D->getNumArgs() == 1) {
+      PredOS << '!';
+      return emitPredicateMatchAux(*D->getArg(0), true, PredOS);
+    }
+    if ((Op == "any_of" || Op == "all_of") && D->getNumArgs() > 0) {
+      bool const Paren =
+          D->getNumArgs() > 1 && std::exchange(ParenIfBinOp, true);
+      if (Paren)
+        PredOS << '(';
+      ListSeparator LS(Op == "any_of" ? " || " : " && ");
+      for (auto *Arg : D->getArgs()) {
+        PredOS << LS;
+        if (emitPredicateMatchAux(*Arg, ParenIfBinOp, PredOS))
+          return true;
+      }
+      if (Paren)
+        PredOS << ')';
+      return false;
+    }
+  }
+  return true;
+}
+
+bool PrinterCapstone::emitPredicateMatch(raw_ostream &PredOS,
+                                         const ListInit *Predicates,
+                                         unsigned Opc) const {
+  bool IsFirstEmission = true;
+  for (unsigned I = 0; I < Predicates->size(); ++I) {
+    Record *Pred = Predicates->getElementAsRecord(I);
+    if (!Pred->getValue("AssemblerMatcherPredicate"))
+      continue;
+
+    if (!isa<DagInit>(Pred->getValue("AssemblerCondDag")->getValue()))
+      continue;
+
+    if (!IsFirstEmission)
+      PredOS << " && ";
+    if (emitPredicateMatchAux(*Pred->getValueAsDag("AssemblerCondDag"),
+                              Predicates->size() > 1, PredOS))
+      PrintFatalError(Pred->getLoc(), "Invalid AssemblerCondDag!");
+    IsFirstEmission = false;
+  }
+  return !Predicates->empty();
+}
+
+void PrinterCapstone::emitFieldFromInstruction() const {
+  OS << "// Helper function for extracting fields from encoded instructions.\n"
+     << "#define FieldFromInstruction(fname, InsnType) \\\n"
+     << "static InsnType fname(InsnType insn, unsigned startBit, unsigned "
+        "numBits) \\\n"
+     << "{ \\\n"
+     << "  InsnType fieldMask; \\\n"
+     << "  if (numBits == sizeof(InsnType) * 8) \\\n"
+     << "    fieldMask = (InsnType)(-1LL); \\\n"
+     << "  else \\\n"
+     << "    fieldMask = (((InsnType)1 << numBits) - 1) << startBit; \\\n"
+     << "  return (insn & fieldMask) >> startBit; \\\n"
+     << "}\n\n";
+}
+
+void PrinterCapstone::emitInsertBits() const { return; }
+
+void PrinterCapstone::emitDecodeInstruction(bool IsVarLenInst) const {
+  OS << "#define DecodeInstruction(fname, fieldname, decoder, InsnType) \\\n"
+     << "static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], "
+        "MCInst &MI, \\\n"
+     << "                                      InsnType insn, uint64_t "
+        "Address) { \\\n"
+     << "  const uint8_t *Ptr = DecodeTable; \\\n"
+     << "  uint64_t CurFieldValue = 0; \\\n"
+     << "  DecodeStatus S = MCDisassembler_Success; \\\n"
+     << "  while (true) { \\\n"
+     << "    ptrdiff_t Loc = Ptr - DecodeTable; \\\n"
+     << "    switch (*Ptr) { \\\n"
+     << "    default: \\\n"
+     << "      errs() << Loc << \": Unexpected decode table opcode!\\n\"; \\\n"
+     << "      return MCDisassembler_Fail; \\\n"
+     << "    case MCD_OPC_ExtractField: { \\\n"
+     << "      unsigned Start = *++Ptr; \\\n"
+     << "      unsigned Len = *++Ptr; \\\n"
+     << "      ++Ptr; \\\n";
+  if (IsVarLenInst) {
+    OS << "      makeUp(insn, Start + Len); \\\n";
+  }
+  OS << "      CurFieldValue = fieldname(insn, Start, Len); \\\n"
+     << "      break; \\\n"
+     << "    } \\\n"
+     << "    case MCD_OPC_FilterValue: { \\\n"
+     << "      /* Decode the field value. */ \\\n"
+     << "      unsigned Len; \\\n"
+     << "      uint64_t Val = decodeULEB128(++Ptr, &Len); \\\n"
+     << "      Ptr += Len; \\\n"
+     << "      /* NumToSkip is a plain 24-bit integer. */ \\\n"
+     << "      unsigned NumToSkip = *Ptr++; \\\n"
+     << "      NumToSkip |= (*Ptr++) << 8; \\\n"
+     << "      NumToSkip |= (*Ptr++) << 16; \\\n"
+     << "      /* Perform the filter operation. */ \\\n"
+     << "      if (Val != CurFieldValue) \\\n"
+     << "        Ptr += NumToSkip; \\\n"
+     << "      break; \\\n"
+     << "    } \\\n"
+     << "    case MCD_OPC_CheckField: { \\\n"
+     << "      unsigned Start = *++Ptr; \\\n"
+     << "      unsigned Len = *++Ptr; \\\n";
+  if (IsVarLenInst) {
+    OS << "      makeUp(insn, Start + Len); \\\n";
+  }
+  OS << "      uint64_t FieldValue = fieldname(insn, Start, Len); "
+        "\\\n"
+     << "      /* Decode the field value. */ \\\n"
+     << "      unsigned PtrLen = 0; \\\n"
+     << "      uint64_t ExpectedValue = decodeULEB128(++Ptr, &PtrLen); \\\n"
+     << "      Ptr += PtrLen; \\\n"
+     << "      /* NumToSkip is a plain 24-bit integer. */ \\\n"
+     << "      unsigned NumToSkip = *Ptr++; \\\n"
+     << "      NumToSkip |= (*Ptr++) << 8; \\\n"
+     << "      NumToSkip |= (*Ptr++) << 16; \\\n"
+     << "      /* If the actual and expected values don't match, skip. */ \\\n"
+     << "      if (ExpectedValue != FieldValue) \\\n"
+     << "        Ptr += NumToSkip; \\\n"
+     << "      break; \\\n"
+     << "    } \\\n"
+     << "    case MCD_OPC_CheckPredicate: { \\\n"
+     << "      unsigned Len; \\\n"
+     << "      /* Decode the Predicate Index value. */ \\\n"
+     << "      unsigned PIdx = decodeULEB128(++Ptr, &Len); \\\n"
+     << "      Ptr += Len; \\\n"
+     << "      /* NumToSkip is a plain 24-bit integer. */ \\\n"
+     << "      unsigned NumToSkip = *Ptr++; \\\n"
+     << "      NumToSkip |= (*Ptr++) << 8; \\\n"
+     << "      NumToSkip |= (*Ptr++) << 16; \\\n"
+     << "      /* Check the predicate. */ \\\n"
+     << "      bool Pred; \\\n"
+     << "      if (!(Pred = checkDecoderPredicate(PIdx, Bits))) \\\n"
+     << "        Ptr += NumToSkip; \\\n"
+     << "      (void)Pred; \\\n"
+     << "      break; \\\n"
+     << "    } \\\n"
+     << "    case MCD_OPC_Decode: { \\\n"
+     << "      unsigned Len; \\\n"
+     << "      /* Decode the Opcode value. */ \\\n"
+     << "      unsigned Opc = decodeULEB128(++Ptr, &Len); \\\n"
+     << "      Ptr += Len; \\\n"
+     << "      unsigned DecodeIdx = decodeULEB128(Ptr, &Len); \\\n"
+     << "      Ptr += Len; \\\n"
+     << "      MCInst_clear(MI); \\\n"
+     << "      MCInst_setOpcode(MI, Opc); \\\n"
+     << "      bool DecodeComplete; \\\n";
+  if (IsVarLenInst) {
+    OS << "      Len = InstrLenTable[Opc]; \\\n"
+       << "      makeUp(insn, Len); \\\n";
+  }
+  OS << "      S = decoder(S, DecodeIdx, insn, MI, Address, "
+        "&DecodeComplete); \\\n"
+     << "      return S; \\\n"
+     << "    } \\\n"
+     << "    case MCD_OPC_TryDecode: { \\\n"
+     << "      unsigned Len; \\\n"
+     << "      /* Decode the Opcode value. */ \\\n"
+     << "      unsigned Opc = decodeULEB128(++Ptr, &Len); \\\n"
+     << "      Ptr += Len; \\\n"
+     << "      unsigned DecodeIdx = decodeULEB128(Ptr, &Len); \\\n"
+     << "      Ptr += Len; \\\n"
+     << "      /* NumToSkip is a plain 24-bit integer. */ \\\n"
+     << "      unsigned NumToSkip = *Ptr++; \\\n"
+     << "      NumToSkip |= (*Ptr++) << 8; \\\n"
+     << "      NumToSkip |= (*Ptr++) << 16; \\\n"
+     << "      /* Perform the decode operation. */ \\\n"
+     << "      MCInst_setOpcode(MI, Opc); \\\n"
+     << "      bool DecodeComplete; \\\n"
+     << "      S = decoder(S, DecodeIdx, insn, MI, Address, "
+     << "&DecodeComplete); \\\n"
+     << "      if (DecodeComplete) { \\\n"
+     << "        /* Decoding complete. */ \\\n"
+     << "        return S; \\\n"
+     << "      } else { \\\n"
+     << "        /* If the decoding was incomplete, skip. */ \\\n"
+     << "        Ptr += NumToSkip; \\\n"
+     << "        /* Reset decode status. This also drops a SoftFail status "
+        "that could be */ \\\n"
+     << "        /* set before the decode attempt. */ \\\n"
+     << "        S = MCDisassembler_Success; \\\n"
+     << "      } \\\n"
+     << "      break; \\\n"
+     << "    } \\\n"
+     << "    case MCD_OPC_SoftFail: { \\\n"
+     << "      /* Decode the mask values. */ \\\n"
+     << "      unsigned Len; \\\n"
+     << "      uint64_t PositiveMask = decodeULEB128(++Ptr, &Len); \\\n"
+     << "      Ptr += Len; \\\n"
+     << "      uint64_t NegativeMask = decodeULEB128(Ptr, &Len); \\\n"
+     << "      Ptr += Len; \\\n"
+     << "      bool Fail = (insn & PositiveMask) != 0 || (~insn & "
+        "NegativeMask) != 0; \\\n"
+     << "      if (Fail) \\\n"
+     << "        S = MCDisassembler_SoftFail; \\\n"
+     << "      break; \\\n"
+     << "    } \\\n"
+     << "    case MCD_OPC_Fail: { \\\n"
+     << "      return MCDisassembler_Fail; \\\n"
+     << "    } \\\n"
+     << "    } \\\n"
+     << "  } \\\n"
+     << "  /* Bogisity detected in disassembler state machine! */ \\\n"
+     << "}\n\n";
+  OS << "FieldFromInstruction(fieldFromInstruction_2, uint16_t)\n"
+     << "DecodeToMCInst(decodeToMCInst_2, fieldFromInstruction_2, uint16_t)\n"
+     << "DecodeInstruction(decodeInstruction_2, fieldFromInstruction_2, "
+        "decodeToMCInst_2, uint16_t)\n"
+     << "\n"
+     << "FieldFromInstruction(fieldFromInstruction_4, uint32_t)\n"
+     << "DecodeToMCInst(decodeToMCInst_4, fieldFromInstruction_4, uint32_t)\n"
+     << "DecodeInstruction(decodeInstruction_4, fieldFromInstruction_4, "
+        "decodeToMCInst_4, uint32_t)\n";
+}
+
+void PrinterCapstone::emitTable(
+    DecoderTable &Table, unsigned BitWidth, StringRef Namespace,
+    std::vector<EncodingAndInst> NumberedEncodings) const {
+  unsigned Indent = 0;
+  OS.indent(Indent) << "static const uint8_t DecoderTable" << Namespace
+                    << BitWidth << "[] = {\n";
+
+  Indent += 2;
+
+  // FIXME: We may be able to use the NumToSkip values to recover
+  // appropriate indentation levels.
+  DecoderTable::const_iterator I = Table.begin();
+  DecoderTable::const_iterator const E = Table.end();
+  while (I != E) {
+    assert(I < E && "incomplete decode table entry!");
+
+    uint64_t const Pos = I - Table.begin();
+    OS << "/* " << Pos << " */";
+    OS.PadToColumn(12);
+
+    switch (*I) {
+    default:
+      PrintFatalError("invalid decode table opcode");
+    case MCD::OPC_ExtractField: {
+      ++I;
+      unsigned const Start = *I++;
+      unsigned const Len = *I++;
+      OS.indent(Indent) << "MCD_OPC_ExtractField, " << Start << ", " << Len
+                        << ",  // Inst{";
+      if (Len > 1)
+        OS << (Start + Len - 1) << "-";
+      OS << Start << "} ...\n";
+      break;
+    }
+    case MCD::OPC_FilterValue: {
+      ++I;
+      OS.indent(Indent) << "MCD_OPC_FilterValue, ";
+      // The filter value is ULEB128 encoded.
+      while (*I >= 128)
+        OS << (unsigned)*I++ << ", ";
+      OS << (unsigned)*I++ << ", ";
+
+      // 24-bit numtoskip value.
+      uint8_t Byte = *I++;
+      uint32_t NumToSkip = Byte;
+      OS << (unsigned)Byte << ", ";
+      Byte = *I++;
+      OS << (unsigned)Byte << ", ";
+      NumToSkip |= Byte << 8;
+      Byte = *I++;
+      OS << utostr(Byte) << ", ";
+      NumToSkip |= Byte << 16;
+      OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
+      break;
+    }
+    case MCD::OPC_CheckField: {
+      ++I;
+      unsigned const Start = *I++;
+      unsigned const Len = *I++;
+      OS.indent(Indent) << "MCD_OPC_CheckField, " << Start << ", " << Len
+                        << ", "; // << Val << ", " << NumToSkip << ",\n";
+      // ULEB128 encoded field value.
+      for (; *I >= 128; ++I)
+        OS << (unsigned)*I << ", ";
+      OS << (unsigned)*I++ << ", ";
+      // 24-bit numtoskip value.
+      uint8_t Byte = *I++;
+      uint32_t NumToSkip = Byte;
+      OS << (unsigned)Byte << ", ";
+      Byte = *I++;
+      OS << (unsigned)Byte << ", ";
+      NumToSkip |= Byte << 8;
+      Byte = *I++;
+      OS << utostr(Byte) << ", ";
+      NumToSkip |= Byte << 16;
+      OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
+      break;
+    }
+    case MCD::OPC_CheckPredicate: {
+      ++I;
+      OS.indent(Indent) << "MCD_OPC_CheckPredicate, ";
+      for (; *I >= 128; ++I)
+        OS << (unsigned)*I << ", ";
+      OS << (unsigned)*I++ << ", ";
+
+      // 24-bit numtoskip value.
+      uint8_t Byte = *I++;
+      uint32_t NumToSkip = Byte;
+      OS << (unsigned)Byte << ", ";
+      Byte = *I++;
+      OS << (unsigned)Byte << ", ";
+      NumToSkip |= Byte << 8;
+      Byte = *I++;
+      OS << utostr(Byte) << ", ";
+      NumToSkip |= Byte << 16;
+      OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
+      break;
+    }
+    case MCD::OPC_Decode:
+    case MCD::OPC_TryDecode: {
+      bool const IsTry = *I == MCD::OPC_TryDecode;
+      ++I;
+      // Extract the ULEB128 encoded Opcode to a buffer.
+      uint8_t Buffer[16], *P = Buffer;
+      while ((*P++ = *I++) >= 128)
+        assert((P - Buffer) <= (ptrdiff_t)sizeof(Buffer) &&
+               "ULEB128 value too large!");
+      // Decode the Opcode value.
+      unsigned const Opc = decodeULEB128(Buffer);
+      OS.indent(Indent) << "MCD_OPC_" << (IsTry ? "Try" : "") << "Decode, ";
+      for (P = Buffer; *P >= 128; ++P)
+        OS << (unsigned)*P << ", ";
+      OS << (unsigned)*P << ", ";
+
+      // Decoder index.
+      for (; *I >= 128; ++I)
+        OS << (unsigned)*I << ", ";
+      OS << (unsigned)*I++ << ", ";
+
+      if (!IsTry) {
+        OS << "// Opcode: " << NumberedEncodings[Opc] << "\n";
+        break;
+      }
+
+      // Fallthrough for OPC_TryDecode.
+
+      // 24-bit numtoskip value.
+      uint8_t Byte = *I++;
+      uint32_t NumToSkip = Byte;
+      OS << (unsigned)Byte << ", ";
+      Byte = *I++;
+      OS << (unsigned)Byte << ", ";
+      NumToSkip |= Byte << 8;
+      Byte = *I++;
+      OS << utostr(Byte) << ", ";
+      NumToSkip |= Byte << 16;
+
+      OS << "// Opcode: " << NumberedEncodings[Opc]
+         << ", skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
+      break;
+    }
+    case MCD::OPC_SoftFail: {
+      ++I;
+      OS.indent(Indent) << "MCD_OPC_SoftFail";
+      // Positive mask
+      uint64_t Value = 0;
+      unsigned Shift = 0;
+      do {
+        OS << ", " << (unsigned)*I;
+        Value += (*I & 0x7f) << Shift;
+        Shift += 7;
+      } while (*I++ >= 128);
+      if (Value > 127) {
+        OS << " /* 0x";
+        OS.write_hex(Value);
+        OS << " */";
+      }
+      // Negative mask
+      Value = 0;
+      Shift = 0;
+      do {
+        OS << ", " << (unsigned)*I;
+        Value += (*I & 0x7f) << Shift;
+        Shift += 7;
+      } while (*I++ >= 128);
+      if (Value > 127) {
+        OS << " /* 0x";
+        OS.write_hex(Value);
+        OS << " */";
+      }
+      OS << ",\n";
+      break;
+    }
+    case MCD::OPC_Fail: {
+      ++I;
+      OS.indent(Indent) << "MCD_OPC_Fail,\n";
+      break;
+    }
+    }
+  }
+  OS.indent(Indent) << "0\n";
+
+  Indent -= 2;
+
+  OS.indent(Indent) << "};\n\n";
+}
+
+void PrinterCapstone::emitInstrLenTable(std::vector<unsigned> &InstrLen) const {
+  OS << "static const uint8_t InstrLenTable[] = {\n";
+  for (unsigned const &Len : InstrLen) {
+    OS << Len << ",\n";
+  }
+  OS << "};\n\n";
+}
+
+void PrinterCapstone::emitPredicateFunction(PredicateSet &Predicates,
+                                            unsigned Indentation) const {
+  // The predicate function is just a big switch statement based on the
+  // input predicate index.
+  OS.indent(Indentation) << "static bool checkDecoderPredicate(unsigned Idx, "
+                         << "const FeatureBitset &Bits) {\n";
+  Indentation += 2;
+  if (!Predicates.empty()) {
+    OS.indent(Indentation) << "switch (Idx) {\n";
+    OS.indent(Indentation)
+        << "default: /* llvm_unreachable(\"Invalid index!\"); */\n";
+    unsigned Index = 0;
+    for (const auto &Predicate : Predicates) {
+      OS.indent(Indentation) << "case " << Index++ << ":\n";
+      OS.indent(Indentation + 2) << "return (" << Predicate << ");\n";
+    }
+    OS.indent(Indentation) << "}\n";
+  } else {
+    // No case statement to emit
+    OS.indent(Indentation) << "/* llvm_unreachable(\"Invalid index!\"); */\n";
+  }
+  Indentation -= 2;
+  OS.indent(Indentation) << "}\n\n";
+}
+
+void PrinterCapstone::emitDecoderFunction(DecoderSet &Decoders,
+                                          unsigned Indentation) const {
+  // The decoder function is just a big switch statement based on the
+  // input decoder index.
+  OS.indent(Indentation)
+      << "#define DecodeToMCInst(fname, fieldname, InsnType) \\\n"
+      << "static DecodeStatus fname(DecodeStatus S, unsigned Idx, InsnType "
+         "insn, MCInst *MI, \\\n"
+      << "   uint64_t Address, bool *Decoder) \\\n"
+      << "{ \\\n";
+  Indentation += 2;
+  OS.indent(Indentation) << "InsnType tmp; \\\n";
+  OS.indent(Indentation) << "switch (Idx) { \\\n";
+  OS.indent(Indentation)
+      << "default: /* llvm_unreachable(\"Invalid index!\"); */ \\\n";
+  unsigned Index = 0;
+  for (const auto &Decoder : Decoders) {
+    OS.indent(Indentation) << "case " << Index++ << ": \\\n";
+    OS << Decoder;
+    OS.indent(Indentation + 2) << "return S; \\\n";
+  }
+  OS.indent(Indentation) << "} \\\n";
+  Indentation -= 2;
+  OS.indent(Indentation) << "}\n\n";
+}
+
+void PrinterCapstone::emitIncludes() const {
+  OS << "#include \"../../MCInst.h\"\n"
+     << "#include \"../../LEB128.h\"\n\n";
+}
+
+void PrinterCapstone::emitNamespaceBegin(std::string const &Namespace) const {
+  return;
+}
+void PrinterCapstone::emitNamespaceEnd(std::string const &Namespace) const {
+  return;
+}
+
+void PrinterCapstone::emitSourceFileHeader() const {
+  OS << "/* Capstone Disassembly Engine, http://www.capstone-engine.org */\n";
+  OS << "/* By Nguyen Anh Quynh <[e-mail]>, 2013-2022, */\n";
+  OS << "/*    Rot127 <[e-mail]> 2022 */\n";
+  OS << "/* Automatically generated file by the LLVM TableGen Disassembler "
+        "Backend. */\n";
+  OS << "/* Do not edit. */\n\n";
+}
+
+} // end namespace tblgen_decoder_emitter

llvm/utils/TableGen/DecoderEmitter/PrinterLLVM.cpp

+//===----------------- PrinterLLVM.cpp - Printer LLVM -----------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Emits the generated decoder C++ code for the LLVM disassembler.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Printer.h"
+#include "llvm/TableGen/TableGenBackend.h"
+
+using namespace llvm;
+namespace tblgen_decoder_emitter {
+
+PrinterInterface::PrinterInterface(formatted_raw_ostream &OS,
+                                   std::string PredicateNamespace,
+                                   std::string GPrefix, std::string GPostfix,
+                                   std::string ROK, std::string RFail,
+                                   std::string L, std::string Target)
+    : OS(OS), TargetName(std::move(Target)),
+      PredicateNamespace(std::move(PredicateNamespace)),
+      GuardPrefix(std::move(GPrefix)), GuardPostfix(std::move(GPostfix)),
+      ReturnOK(std::move(ROK)), ReturnFail(std::move(RFail)),
+      Locals(std::move(L)) {}
+
+PrinterInterface::~PrinterInterface() {}
+
+void PrinterInterface::flushOS() const { OS.flush(); }
+
+void PrinterLLVM::emitOpDecoder(raw_ostream &DecoderOS,
+                                const OperandInfo &Op) const {
+  unsigned const Indent = 4;
+  DecoderOS.indent(Indent) << GuardPrefix << Op.Decoder
+                           << "(MI, insn, Address, Decoder)" << GuardPostfix
+                           << " { "
+                           << (Op.HasCompleteDecoder
+                                   ? ""
+                                   : "DecodeComplete = false; ")
+                           << "return MCDisassembler::Fail; }\n";
+}
+
+void PrinterLLVM::emitOpBinaryParser(raw_ostream &DecOS,
+                                     const OperandInfo &OpInfo) const {
+  unsigned const Indent = 4;
+  const std::string &Decoder = OpInfo.Decoder;
+
+  bool const UseInsertBits = OpInfo.numFields() != 1 || OpInfo.InitValue != 0;
+
+  if (UseInsertBits) {
+    DecOS.indent(Indent) << "tmp = 0x";
+    DecOS.write_hex(OpInfo.InitValue);
+    DecOS << ";\n";
+  }
+
+  for (const EncodingField &EF : OpInfo) {
+    DecOS.indent(Indent);
+    if (UseInsertBits)
+      DecOS << "insertBits(tmp, ";
+    else
+      DecOS << "tmp = ";
+    DecOS << "fieldFromInstruction(insn, " << EF.Base << ", " << EF.Width
+          << ')';
+    if (UseInsertBits)
+      DecOS << ", " << EF.Offset << ", " << EF.Width << ')';
+    else if (EF.Offset != 0)
+      DecOS << " << " << EF.Offset;
+    DecOS << ";\n";
+  }
+
+  if (Decoder != "") {
+    DecOS.indent(Indent) << GuardPrefix << Decoder
+                         << "(MI, tmp, Address, Decoder)" << GuardPostfix
+                         << " { "
+                         << (OpInfo.HasCompleteDecoder
+                                 ? ""
+                                 : "DecodeComplete = false; ")
+                         << "return MCDisassembler::Fail; }\n";
+  } else {
+    DecOS.indent(Indent) << "MI.addOperand(MCOperand::createImm(tmp));\n";
+  }
+}
+
+// If ParenIfBinOp is true, print a surrounding () if Val uses && or ||.
+bool PrinterLLVM::emitPredicateMatchAux(const Init &Val, bool ParenIfBinOp,
+                                        raw_ostream &PredOS) const {
+  if (auto *D = dyn_cast<DefInit>(&Val)) {
+    if (!D->getDef()->isSubClassOf("SubtargetFeature"))
+      return true;
+    PredOS << "Bits[" << PredicateNamespace << "::" << D->getAsString() << "]";
+    return false;
+  }
+  if (auto *D = dyn_cast<DagInit>(&Val)) {
+    std::string const Op = D->getOperator()->getAsString();
+    if (Op == "not" && D->getNumArgs() == 1) {
+      PredOS << '!';
+      return emitPredicateMatchAux(*D->getArg(0), true, PredOS);
+    }
+    if ((Op == "any_of" || Op == "all_of") && D->getNumArgs() > 0) {
+      bool const Paren =
+          D->getNumArgs() > 1 && std::exchange(ParenIfBinOp, true);
+      if (Paren)
+        PredOS << '(';
+      ListSeparator LS(Op == "any_of" ? " || " : " && ");
+      for (auto *Arg : D->getArgs()) {
+        PredOS << LS;
+        if (emitPredicateMatchAux(*Arg, ParenIfBinOp, PredOS))
+          return true;
+      }
+      if (Paren)
+        PredOS << ')';
+      return false;
+    }
+  }
+  return true;
+}
+
+bool PrinterLLVM::emitPredicateMatch(raw_ostream &PredOS,
+                                     const ListInit *Predicates,
+                                     unsigned Opc) const {
+  bool IsFirstEmission = true;
+  for (unsigned I = 0; I < Predicates->size(); ++I) {
+    Record *Pred = Predicates->getElementAsRecord(I);
+    if (!Pred->getValue("AssemblerMatcherPredicate"))
+      continue;
+
+    if (!isa<DagInit>(Pred->getValue("AssemblerCondDag")->getValue()))
+      continue;
+
+    if (!IsFirstEmission)
+      PredOS << " && ";
+    if (emitPredicateMatchAux(*Pred->getValueAsDag("AssemblerCondDag"),
+                              Predicates->size() > 1, PredOS))
+      PrintFatalError(Pred->getLoc(), "Invalid AssemblerCondDag!");
+    IsFirstEmission = false;
+  }
+  return !Predicates->empty();
+}
+
+// emitFieldFromInstruction - Emit the templated helper function
+// fieldFromInstruction().
+// On Windows we make sure that this function is not inlined when
+// using the VS compiler. It has a bug which causes the function
+// to be optimized out in some circustances. See llvm.org/pr38292
+void PrinterLLVM::emitFieldFromInstruction() const {
+  OS << "// Helper functions for extracting fields from encoded instructions.\n"
+     << "// InsnType must either be integral or an APInt-like object that "
+        "must:\n"
+     << "// * be default-constructible and copy-constructible\n"
+     << "// * be constructible from an APInt (this can be private)\n"
+     << "// * Support insertBits(bits, startBit, numBits)\n"
+     << "// * Support extractBitsAsZExtValue(numBits, startBit)\n"
+     << "// * Support the ~, &, ==, and != operators with other objects of "
+        "the same type\n"
+     << "// * Support the != and bitwise & with uint64_t\n"
+     << "// * Support put (<<) to raw_ostream&\n"
+     << "template <typename InsnType>\n"
+     << "#if defined(_MSC_VER) && !defined(__clang__)\n"
+     << "__declspec(noinline)\n"
+     << "#endif\n"
+     << "static std::enable_if_t<std::is_integral<InsnType>::value, InsnType>\n"
+     << "fieldFromInstruction(const InsnType &insn, unsigned startBit,\n"
+     << "                     unsigned numBits) {\n"
+     << "  assert(startBit + numBits <= 64 && \"Cannot support >64-bit "
+        "extractions!\");\n"
+     << "  assert(startBit + numBits <= (sizeof(InsnType) * 8) &&\n"
+     << "         \"Instruction field out of bounds!\");\n"
+     << "  InsnType fieldMask;\n"
+     << "  if (numBits == sizeof(InsnType) * 8)\n"
+     << "    fieldMask = (InsnType)(-1LL);\n"
+     << "  else\n"
+     << "    fieldMask = (((InsnType)1 << numBits) - 1) << startBit;\n"
+     << "  return (insn & fieldMask) >> startBit;\n"
+     << "}\n"
+     << "\n"
+     << "template <typename InsnType>\n"
+     << "static std::enable_if_t<!std::is_integral<InsnType>::value, "
+        "uint64_t>\n"
+     << "fieldFromInstruction(const InsnType &insn, unsigned startBit,\n"
+     << "                     unsigned numBits) {\n"
+     << "  return insn.extractBitsAsZExtValue(numBits, startBit);\n"
+     << "}\n\n";
+}
+
+// emitInsertBits - Emit the templated helper function insertBits().
+void PrinterLLVM::emitInsertBits() const {
+  OS << "// Helper function for inserting bits extracted from an encoded "
+        "instruction into\n"
+     << "// a field.\n"
+     << "template <typename InsnType>\n"
+     << "static std::enable_if_t<std::is_integral<InsnType>::value>\n"
+     << "insertBits(InsnType &field, InsnType bits, unsigned startBit, "
+        "unsigned numBits) {\n"
+     << "  assert(startBit + numBits <= sizeof field * 8);\n"
+     << "  field |= (InsnType)bits << startBit;\n"
+     << "}\n"
+     << "\n"
+     << "template <typename InsnType>\n"
+     << "static std::enable_if_t<!std::is_integral<InsnType>::value>\n"
+     << "insertBits(InsnType &field, uint64_t bits, unsigned startBit, "
+        "unsigned numBits) {\n"
+     << "  field.insertBits(bits, startBit, numBits);\n"
+     << "}\n\n";
+}
+
+// emitDecodeInstruction - Emit the templated helper function
+// decodeInstruction().
+void PrinterLLVM::emitDecodeInstruction(bool IsVarLenInst) const {
+  OS << "template <typename InsnType>\n"
+     << "static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], "
+        "MCInst &MI,\n"
+     << "                                      InsnType insn, uint64_t "
+        "Address,\n"
+     << "                                      const MCDisassembler *DisAsm,\n"
+     << "                                      const MCSubtargetInfo &STI";
+  if (IsVarLenInst) {
+    OS << ",\n"
+       << "                                      llvm::function_ref<void(APInt "
+          "&,"
+       << " uint64_t)> makeUp";
+  }
+  OS << ") {\n"
+     << "  const FeatureBitset &Bits = STI.getFeatureBits();\n"
+     << "\n"
+     << "  const uint8_t *Ptr = DecodeTable;\n"
+     << "  uint64_t CurFieldValue = 0;\n"
+     << "  DecodeStatus S = MCDisassembler::Success;\n"
+     << "  while (true) {\n"
+     << "    ptrdiff_t Loc = Ptr - DecodeTable;\n"
+     << "    switch (*Ptr) {\n"
+     << "    default:\n"
+     << "      errs() << Loc << \": Unexpected decode table opcode!\\n\";\n"
+     << "      return MCDisassembler::Fail;\n"
+     << "    case MCD::OPC_ExtractField: {\n"
+     << "      unsigned Start = *++Ptr;\n"
+     << "      unsigned Len = *++Ptr;\n"
+     << "      ++Ptr;\n";
+  if (IsVarLenInst) {
+    OS << "      makeUp(insn, Start + Len);\n";
+  }
+  OS << "      CurFieldValue = fieldFromInstruction(insn, Start, Len);\n"
+     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_ExtractField(\" << Start << "
+        "\", \"\n"
+     << "                   << Len << \"): \" << CurFieldValue << \"\\n\");\n"
+     << "      break;\n"
+     << "    }\n"
+     << "    case MCD::OPC_FilterValue: {\n"
+     << "      // Decode the field value.\n"
+     << "      unsigned Len;\n"
+     << "      uint64_t Val = decodeULEB128(++Ptr, &Len);\n"
+     << "      Ptr += Len;\n"
+     << "      // NumToSkip is a plain 24-bit integer.\n"
+     << "      unsigned NumToSkip = *Ptr++;\n"
+     << "      NumToSkip |= (*Ptr++) << 8;\n"
+     << "      NumToSkip |= (*Ptr++) << 16;\n"
+     << "\n"
+     << "      // Perform the filter operation.\n"
+     << "      if (Val != CurFieldValue)\n"
+     << "        Ptr += NumToSkip;\n"
+     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_FilterValue(\" << Val << "
+        "\", \" << NumToSkip\n"
+     << "                   << \"): \" << ((Val != CurFieldValue) ? \"FAIL:\" "
+        ": \"PASS:\")\n"
+     << "                   << \" continuing at \" << (Ptr - DecodeTable) << "
+        "\"\\n\");\n"
+     << "\n"
+     << "      break;\n"
+     << "    }\n"
+     << "    case MCD::OPC_CheckField: {\n"
+     << "      unsigned Start = *++Ptr;\n"
+     << "      unsigned Len = *++Ptr;\n";
+  if (IsVarLenInst) {
+    OS << "      makeUp(insn, Start + Len);\n";
+  }
+  OS << "      uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);\n"
+     << "      // Decode the field value.\n"
+     << "      unsigned PtrLen = 0;\n"
+     << "      uint64_t ExpectedValue = decodeULEB128(++Ptr, &PtrLen);\n"
+     << "      Ptr += PtrLen;\n"
+     << "      // NumToSkip is a plain 24-bit integer.\n"
+     << "      unsigned NumToSkip = *Ptr++;\n"
+     << "      NumToSkip |= (*Ptr++) << 8;\n"
+     << "      NumToSkip |= (*Ptr++) << 16;\n"
+     << "\n"
+     << "      // If the actual and expected values don't match, skip.\n"
+     << "      if (ExpectedValue != FieldValue)\n"
+     << "        Ptr += NumToSkip;\n"
+     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_CheckField(\" << Start << "
+        "\", \"\n"
+     << "                   << Len << \", \" << ExpectedValue << \", \" << "
+        "NumToSkip\n"
+     << "                   << \"): FieldValue = \" << FieldValue << \", "
+        "ExpectedValue = \"\n"
+     << "                   << ExpectedValue << \": \"\n"
+     << "                   << ((ExpectedValue == FieldValue) ? \"PASS\\n\" : "
+        "\"FAIL\\n\"));\n"
+     << "      break;\n"
+     << "    }\n"
+     << "    case MCD::OPC_CheckPredicate: {\n"
+     << "      unsigned Len;\n"
+     << "      // Decode the Predicate Index value.\n"
+     << "      unsigned PIdx = decodeULEB128(++Ptr, &Len);\n"
+     << "      Ptr += Len;\n"
+     << "      // NumToSkip is a plain 24-bit integer.\n"
+     << "      unsigned NumToSkip = *Ptr++;\n"
+     << "      NumToSkip |= (*Ptr++) << 8;\n"
+     << "      NumToSkip |= (*Ptr++) << 16;\n"
+     << "      // Check the predicate.\n"
+     << "      bool Pred;\n"
+     << "      if (!(Pred = checkDecoderPredicate(PIdx, Bits)))\n"
+     << "        Ptr += NumToSkip;\n"
+     << "      (void)Pred;\n"
+     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_CheckPredicate(\" << PIdx "
+        "<< \"): \"\n"
+     << "            << (Pred ? \"PASS\\n\" : \"FAIL\\n\"));\n"
+     << "\n"
+     << "      break;\n"
+     << "    }\n"
+     << "    case MCD::OPC_Decode: {\n"
+     << "      unsigned Len;\n"
+     << "      // Decode the Opcode value.\n"
+     << "      unsigned Opc = decodeULEB128(++Ptr, &Len);\n"
+     << "      Ptr += Len;\n"
+     << "      unsigned DecodeIdx = decodeULEB128(Ptr, &Len);\n"
+     << "      Ptr += Len;\n"
+     << "\n"
+     << "      MI.clear();\n"
+     << "      MI.setOpcode(Opc);\n"
+     << "      bool DecodeComplete;\n";
+  if (IsVarLenInst) {
+    OS << "      Len = InstrLenTable[Opc];\n"
+       << "      makeUp(insn, Len);\n";
+  }
+  OS << "      S = decodeToMCInst(S, DecodeIdx, insn, MI, Address, DisAsm, "
+        "DecodeComplete);\n"
+     << "      assert(DecodeComplete);\n"
+     << "\n"
+     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_Decode: opcode \" << Opc\n"
+     << "                   << \", using decoder \" << DecodeIdx << \": \"\n"
+     << "                   << (S != MCDisassembler::Fail ? \"PASS\" : "
+        "\"FAIL\") << \"\\n\");\n"
+     << "      return S;\n"
+     << "    }\n"
+     << "    case MCD::OPC_TryDecode: {\n"
+     << "      unsigned Len;\n"
+     << "      // Decode the Opcode value.\n"
+     << "      unsigned Opc = decodeULEB128(++Ptr, &Len);\n"
+     << "      Ptr += Len;\n"
+     << "      unsigned DecodeIdx = decodeULEB128(Ptr, &Len);\n"
+     << "      Ptr += Len;\n"
+     << "      // NumToSkip is a plain 24-bit integer.\n"
+     << "      unsigned NumToSkip = *Ptr++;\n"
+     << "      NumToSkip |= (*Ptr++) << 8;\n"
+     << "      NumToSkip |= (*Ptr++) << 16;\n"
+     << "\n"
+     << "      // Perform the decode operation.\n"
+     << "      MCInst TmpMI;\n"
+     << "      TmpMI.setOpcode(Opc);\n"
+     << "      bool DecodeComplete;\n"
+     << "      S = decodeToMCInst(S, DecodeIdx, insn, TmpMI, Address, DisAsm, "
+        "DecodeComplete);\n"
+     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_TryDecode: opcode \" << "
+        "Opc\n"
+     << "                   << \", using decoder \" << DecodeIdx << \": \");\n"
+     << "\n"
+     << "      if (DecodeComplete) {\n"
+     << "        // Decoding complete.\n"
+     << "        LLVM_DEBUG(dbgs() << (S != MCDisassembler::Fail ? \"PASS\" : "
+        "\"FAIL\") << \"\\n\");\n"
+     << "        MI = TmpMI;\n"
+     << "        return S;\n"
+     << "      } else {\n"
+     << "        assert(S == MCDisassembler::Fail);\n"
+     << "        // If the decoding was incomplete, skip.\n"
+     << "        Ptr += NumToSkip;\n"
+     << "        LLVM_DEBUG(dbgs() << \"FAIL: continuing at \" << (Ptr - "
+        "DecodeTable) << \"\\n\");\n"
+     << "        // Reset decode status. This also drops a SoftFail status "
+        "that could be\n"
+     << "        // set before the decode attempt.\n"
+     << "        S = MCDisassembler::Success;\n"
+     << "      }\n"
+     << "      break;\n"
+     << "    }\n"
+     << "    case MCD::OPC_SoftFail: {\n"
+     << "      // Decode the mask values.\n"
+     << "      unsigned Len;\n"
+     << "      uint64_t PositiveMask = decodeULEB128(++Ptr, &Len);\n"
+     << "      Ptr += Len;\n"
+     << "      uint64_t NegativeMask = decodeULEB128(Ptr, &Len);\n"
+     << "      Ptr += Len;\n"
+     << "      bool Fail = (insn & PositiveMask) != 0 || (~insn & "
+        "NegativeMask) != 0;\n"
+     << "      if (Fail)\n"
+     << "        S = MCDisassembler::SoftFail;\n"
+     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_SoftFail: \" << (Fail ? "
+        "\"FAIL\\n\" : \"PASS\\n\"));\n"
+     << "      break;\n"
+     << "    }\n"
+     << "    case MCD::OPC_Fail: {\n"
+     << "      LLVM_DEBUG(dbgs() << Loc << \": OPC_Fail\\n\");\n"
+     << "      return MCDisassembler::Fail;\n"
+     << "    }\n"
+     << "    }\n"
+     << "  }\n"
+     << "  llvm_unreachable(\"bogosity detected in disassembler state "
+        "machine!\");\n"
+     << "}\n\n";
+}
+
+// Emit the decoder state machine table.
+void PrinterLLVM::emitTable(
+    DecoderTable &Table, unsigned BitWidth, StringRef Namespace,
+    std::vector<EncodingAndInst> NumberedEncodings) const {
+  unsigned Indent = 0;
+  OS.indent(Indent) << "static const uint8_t DecoderTable" << Namespace
+                    << BitWidth << "[] = {\n";
+
+  Indent += 2;
+
+  // FIXME: We may be able to use the NumToSkip values to recover
+  // appropriate indentation levels.
+  DecoderTable::const_iterator I = Table.begin();
+  DecoderTable::const_iterator const E = Table.end();
+  while (I != E) {
+    assert(I < E && "incomplete decode table entry!");
+
+    uint64_t const Pos = I - Table.begin();
+    OS << "/* " << Pos << " */";
+    OS.PadToColumn(12);
+
+    switch (*I) {
+    default:
+      PrintFatalError("invalid decode table opcode");
+    case MCD::OPC_ExtractField: {
+      ++I;
+      unsigned const Start = *I++;
+      unsigned const Len = *I++;
+      OS.indent(Indent) << "MCD::OPC_ExtractField, " << Start << ", " << Len
+                        << ",  // Inst{";
+      if (Len > 1)
+        OS << (Start + Len - 1) << "-";
+      OS << Start << "} ...\n";
+      break;
+    }
+    case MCD::OPC_FilterValue: {
+      ++I;
+      OS.indent(Indent) << "MCD::OPC_FilterValue, ";
+      // The filter value is ULEB128 encoded.
+      while (*I >= 128)
+        OS << (unsigned)*I++ << ", ";
+      OS << (unsigned)*I++ << ", ";
+
+      // 24-bit numtoskip value.
+      uint8_t Byte = *I++;
+      uint32_t NumToSkip = Byte;
+      OS << (unsigned)Byte << ", ";
+      Byte = *I++;
+      OS << (unsigned)Byte << ", ";
+      NumToSkip |= Byte << 8;
+      Byte = *I++;
+      OS << utostr(Byte) << ", ";
+      NumToSkip |= Byte << 16;
+      OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
+      break;
+    }
+    case MCD::OPC_CheckField: {
+      ++I;
+      unsigned const Start = *I++;
+      unsigned const Len = *I++;
+      OS.indent(Indent) << "MCD::OPC_CheckField, " << Start << ", " << Len
+                        << ", "; // << Val << ", " << NumToSkip << ",\n";
+      // ULEB128 encoded field value.
+      for (; *I >= 128; ++I)
+        OS << (unsigned)*I << ", ";
+      OS << (unsigned)*I++ << ", ";
+      // 24-bit numtoskip value.
+      uint8_t Byte = *I++;
+      uint32_t NumToSkip = Byte;
+      OS << (unsigned)Byte << ", ";
+      Byte = *I++;
+      OS << (unsigned)Byte << ", ";
+      NumToSkip |= Byte << 8;
+      Byte = *I++;
+      OS << utostr(Byte) << ", ";
+      NumToSkip |= Byte << 16;
+      OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
+      break;
+    }
+    case MCD::OPC_CheckPredicate: {
+      ++I;
+      OS.indent(Indent) << "MCD::OPC_CheckPredicate, ";
+      for (; *I >= 128; ++I)
+        OS << (unsigned)*I << ", ";
+      OS << (unsigned)*I++ << ", ";
+
+      // 24-bit numtoskip value.
+      uint8_t Byte = *I++;
+      uint32_t NumToSkip = Byte;
+      OS << (unsigned)Byte << ", ";
+      Byte = *I++;
+      OS << (unsigned)Byte << ", ";
+      NumToSkip |= Byte << 8;
+      Byte = *I++;
+      OS << utostr(Byte) << ", ";
+      NumToSkip |= Byte << 16;
+      OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
+      break;
+    }
+    case MCD::OPC_Decode:
+    case MCD::OPC_TryDecode: {
+      bool const IsTry = *I == MCD::OPC_TryDecode;
+      ++I;
+      // Extract the ULEB128 encoded Opcode to a buffer.
+      uint8_t Buffer[16], *P = Buffer;
+      while ((*P++ = *I++) >= 128)
+        assert((P - Buffer) <= (ptrdiff_t)sizeof(Buffer) &&
+               "ULEB128 value too large!");
+      // Decode the Opcode value.
+      unsigned const Opc = decodeULEB128(Buffer);
+      OS.indent(Indent) << "MCD::OPC_" << (IsTry ? "Try" : "") << "Decode, ";
+      for (P = Buffer; *P >= 128; ++P)
+        OS << (unsigned)*P << ", ";
+      OS << (unsigned)*P << ", ";
+
+      // Decoder index.
+      for (; *I >= 128; ++I)
+        OS << (unsigned)*I << ", ";
+      OS << (unsigned)*I++ << ", ";
+
+      if (!IsTry) {
+        OS << "// Opcode: " << NumberedEncodings[Opc] << "\n";
+        break;
+      }
+
+      // Fallthrough for OPC_TryDecode.
+
+      // 24-bit numtoskip value.
+      uint8_t Byte = *I++;
+      uint32_t NumToSkip = Byte;
+      OS << (unsigned)Byte << ", ";
+      Byte = *I++;
+      OS << (unsigned)Byte << ", ";
+      NumToSkip |= Byte << 8;
+      Byte = *I++;
+      OS << utostr(Byte) << ", ";
+      NumToSkip |= Byte << 16;
+
+      OS << "// Opcode: " << NumberedEncodings[Opc]
+         << ", skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
+      break;
+    }
+    case MCD::OPC_SoftFail: {
+      ++I;
+      OS.indent(Indent) << "MCD::OPC_SoftFail";
+      // Positive mask
+      uint64_t Value = 0;
+      unsigned Shift = 0;
+      do {
+        OS << ", " << (unsigned)*I;
+        Value += (*I & 0x7f) << Shift;
+        Shift += 7;
+      } while (*I++ >= 128);
+      if (Value > 127) {
+        OS << " /* 0x";
+        OS.write_hex(Value);
+        OS << " */";
+      }
+      // Negative mask
+      Value = 0;
+      Shift = 0;
+      do {
+        OS << ", " << (unsigned)*I;
+        Value += (*I & 0x7f) << Shift;
+        Shift += 7;
+      } while (*I++ >= 128);
+      if (Value > 127) {
+        OS << " /* 0x";
+        OS.write_hex(Value);
+        OS << " */";
+      }
+      OS << ",\n";
+      break;
+    }
+    case MCD::OPC_Fail: {
+      ++I;
+      OS.indent(Indent) << "MCD::OPC_Fail,\n";
+      break;
+    }
+    }
+  }
+  OS.indent(Indent) << "0\n";
+
+  Indent -= 2;
+
+  OS.indent(Indent) << "};\n\n";
+}
+
+void PrinterLLVM::emitInstrLenTable(std::vector<unsigned> &InstrLen) const {
+  OS << "static const uint8_t InstrLenTable[] = {\n";
+  for (unsigned const &Len : InstrLen) {
+    OS << Len << ",\n";
+  }
+  OS << "};\n\n";
+}
+
+void PrinterLLVM::emitPredicateFunction(PredicateSet &Predicates,
+                                        unsigned Indentation) const {
+  // The predicate function is just a big switch statement based on the
+  // input predicate index.
+  OS.indent(Indentation) << "static bool checkDecoderPredicate(unsigned Idx, "
+                         << "const FeatureBitset &Bits) {\n";
+  Indentation += 2;
+  if (!Predicates.empty()) {
+    OS.indent(Indentation) << "switch (Idx) {\n";
+    OS.indent(Indentation)
+        << "default: llvm_unreachable(\"Invalid index!\");\n";
+    unsigned Index = 0;
+    for (const auto &Predicate : Predicates) {
+      OS.indent(Indentation) << "case " << Index++ << ":\n";
+      OS.indent(Indentation + 2) << "return (" << Predicate << ");\n";
+    }
+    OS.indent(Indentation) << "}\n";
+  } else {
+    // No case statement to emit
+    OS.indent(Indentation) << "llvm_unreachable(\"Invalid index!\");\n";
+  }
+  Indentation -= 2;
+  OS.indent(Indentation) << "}\n\n";
+}
+
+void PrinterLLVM::emitDecoderFunction(DecoderSet &Decoders,
+                                      unsigned Indentation) const {
+  // The decoder function is just a big switch statement based on the
+  // input decoder index.
+  OS.indent(Indentation) << "template <typename InsnType>\n";
+  OS.indent(Indentation) << "static DecodeStatus decodeToMCInst(DecodeStatus S,"
+                         << " unsigned Idx, InsnType insn, MCInst &MI,\n";
+  OS.indent(Indentation)
+      << "                                   uint64_t "
+      << "Address, const MCDisassembler *Decoder, bool &DecodeComplete) {\n";
+  Indentation += 2;
+  OS.indent(Indentation) << "DecodeComplete = true;\n";
+  // TODO: When InsnType is large, using uint64_t limits all fields to 64 bits
+  // It would be better for emitBinaryParser to use a 64-bit tmp whenever
+  // possible but fall back to an InsnType-sized tmp for truly large fields.
+  OS.indent(Indentation) << "using TmpType = "
+                            "std::conditional_t<std::is_integral<InsnType>::"
+                            "value, InsnType, uint64_t>;\n";
+  OS.indent(Indentation) << "TmpType tmp;\n";
+  OS.indent(Indentation) << "switch (Idx) {\n";
+  OS.indent(Indentation) << "default: llvm_unreachable(\"Invalid index!\");\n";
+  unsigned Index = 0;
+  for (const auto &Decoder : Decoders) {
+    OS.indent(Indentation) << "case " << Index++ << ":\n";
+    OS << Decoder;
+    OS.indent(Indentation + 2) << "return S;\n";
+  }
+  OS.indent(Indentation) << "}\n";
+  Indentation -= 2;
+  OS.indent(Indentation) << "}\n\n";
+}
+
+void PrinterLLVM::emitIncludes() const {
+  OS << "#include \"llvm/MC/MCInst.h\"\n";
+  OS << "#include \"llvm/MC/MCSubtargetInfo.h\"\n";
+  OS << "#include \"llvm/MC/SubtargetFeature.h\"\n";
+  OS << "#include \"llvm/Support/DataTypes.h\"\n";
+  OS << "#include \"llvm/Support/Debug.h\"\n";
+  OS << "#include \"llvm/Support/LEB128.h\"\n";
+  OS << "#include \"llvm/Support/raw_ostream.h\"\n";
+  OS << "#include <assert.h>\n";
+  OS << '\n';
+}
+
+void PrinterLLVM::emitNamespaceBegin(std::string const &Namespace) const {
+  OS << "namespace " << Namespace << " {\n\n";
+}
+void PrinterLLVM::emitNamespaceEnd(std::string const &Namespace) const {
+  OS << "\n} // end namespace " << Namespace << "\n";
+}
+
+void PrinterLLVM::emitSourceFileHeader() const {
+  llvm::emitSourceFileHeader(" * " + TargetName + " Disassembler", OS);
+}
+
+} // end namespace tblgen_decoder_emitter

llvm/utils/TableGen/DecoderEmitter/README.md

+# Decoder emitter
+
+The decoder emitter generates the code for the disassembler of several architectures.
+
+The general design is split into four classes.
+
+- `DecoderEmitter`: Controls code generation and pre-processes `Records`.
+- `FilterChooser`: Builds the decoding state machine.
+- `Filter`: Represents a state in the decoding state machine.
+- `Printer`: Provides the actual code strings.
+
+The rough process of the code generation is described in the following diagram.
+The details about the state machine creation (the `recurse` step) checkout [InstructionDecoding.md](InstructionDecoding.md)
+
+```
+DecoderEmitter                  FilterChooser                           Filter              Printer           Output Stream
+
+    ┌───┐                           ┌───┐                               ┌───┐                ┌───┐                 ┌───┐
+    │   ├────────┐                  │   │                               │   │                │   │                 │   │
+    │   │        │Separate instr.   │   │                               │   │                │   │                 │   │
+    │   │        │into groups       │   │                               │   │                │   │                 │   │
+    │   │        │                  │   │                               │   │                │   │                 │   │
+    │   │◄───────┘                  │   │                               │   │                │   │                 │   │
+    │   │                           │   │                               │   │                │   │                 │   │
+    │   │ Start separation process  │   │ Separate                      │   │                │   │                 │   │
+    │   │ of instr. groups          │   │ into                          │   │                │   │                 │   │
+    │   ├──────────────────────────►│   │ subsets                       │   │                │   │                 │   │
+    │   │                           │   ├───────────┐                   │   │                │   │                 │   │
+    │   │                           │   │           │ Add Filter to     │   │                │   │                 │   │
+    │   │                           │   │           │ Filterlist        │   │                │   │                 │   │
+    │   │                           │   │    R      ├──────────────────►│   │                │   │                 │   │
+    │   │                           │   │    E      │                   │   │                │   │                 │   │
+    │   │                           │   │    C      │                   │   │                │   │                 │   │
+    │   │                           │   │    U      │                   └───┘                │   │                 │   │
+    │   │                           │   │    R      │                                        │   │                 │   │
+    │   │                           │   │    S      │ Request Filter decoder string          │   │                 │   │
+    │   │                           │   │    E      ├───────────────────────────────────────►│   │                 │   │
+    │   │                           │   │           │                                        │   │                 │   │
+    │   │                           │   │           │◄───────────────────────────────────────┤   │                 │   │
+    │   │                           │   │           │ Return decoder string                  │   │                 │   │
+    │   │                           │   │◄──────────┘                                        │   │                 │   │
+    │   │                           │   │                                                    │   │                 │   │
+    │   │                           │   │                                                    │   │                 │   │
+    │   │◄──────────────────────────┤   │                                                    │   │                 │   │
+    │   │  Return list of decoder   │   │                                                    │   │                 │   │
+    │   │  strings                  └───┘                                                    │   │                 │   │
+    │   │                                                                                    │   │                 │   │
+    │   │                                                                                    │   │                 │   │
+    │   │                                                                                    │   │                 │   │
+    │   │                                                                                    │   │                 │   │
+    │   │  Request print decoders into file                                                  │   │ Print           │   │
+    │   ├───────────────────────────────────────────────────────────────────────────────────►│   │ decoders        │   │
+    │   │                                                                                    │   ├────────────────►│   │
+    │   │                                                                                    │   │                 │   │
+    │   │  Request to print helper functions into file                                       │   │ Print           │   │
+    │   ├───────────────────────────────────────────────────────────────────────────────────►│   │ functions       │   │
+    │   │                                                                                    │   ├────────────────►│   │
+    │   │                                                                                    │   │                 │   │
+    └───┘                                                                                    │   │                 │   │
+                                                                                             └───┘                 └───┘
+```

llvm/utils/TableGen/DisassemblerEmitter.cpp

 //===- DisassemblerEmitter.cpp - Generate a disassembler ------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+#include "./DecoderEmitter/Printer.h"
 #include "CodeGenTarget.h"
+#include "TableGenBackends.h"
 #include "WebAssemblyDisassemblerEmitter.h"
 #include "X86DisassemblerTables.h"
 #include "X86RecognizableInstr.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 using namespace llvm;

 /// X86RecognizableInstr.h contains the interface for a single instruction,
 ///   which knows how to translate itself from a CodeGenInstruction and provide
 ///   the information necessary for integration into the tables.
 /// X86RecognizableInstr.cpp contains the implementation for a single
 ///   instruction.
 
 namespace llvm {
 
-extern void EmitDecoder(RecordKeeper &RK, raw_ostream &OS,
-                        const std::string &PredicateNamespace,
-                        const std::string &GPrefix, const std::string &GPostfix,
-                        const std::string &ROK, const std::string &RFail,
-                        const std::string &L);
+void EmitDecoder(RecordKeeper &RK, raw_ostream &OS, CodeGenTarget &Target, ActionType Action);
 
-void EmitDisassembler(RecordKeeper &Records, raw_ostream &OS) {
+void EmitDisassembler(RecordKeeper &Records, raw_ostream &OS, ActionType Action=GenDisassembler) {
   CodeGenTarget Target(Records);
-  emitSourceFileHeader(" * " + Target.getName().str() + " Disassembler", OS);
 
   // X86 uses a custom disassembler.
   if (Target.getName() == "X86") {
+    emitSourceFileHeader(" * " + Target.getName().str() + " Disassembler", OS);
     DisassemblerTables Tables;
 
-    ArrayRef<const CodeGenInstruction*> numberedInstructions =
+    ArrayRef<const CodeGenInstruction *> numberedInstructions =
         Target.getInstructionsByEnumValue();
 
     for (unsigned i = 0, e = numberedInstructions.size(); i != e; ++i)
       RecognizableInstr::processInstr(Tables, *numberedInstructions[i], i);
 
     if (Tables.hasConflicts()) {
       PrintError(Target.getTargetRecord()->getLoc(), "Primary decode conflict");
       return;
     }
 
     Tables.emit(OS);
     return;
   }
 
   // WebAssembly has variable length opcodes, so can't use EmitFixedLenDecoder
   // below (which depends on a Size table-gen Record), and also uses a custom
   // disassembler.
   if (Target.getName() == "WebAssembly") {
+    emitSourceFileHeader(" * " + Target.getName().str() + " Disassembler", OS);
     emitWebAssemblyDisassemblerTables(OS, Target.getInstructionsByEnumValue());
     return;
   }
-
-  // ARM and Thumb have a CHECK() macro to deal with DecodeStatuses.
-  if (Target.getName() == "ARM" || Target.getName() == "Thumb" ||
-      Target.getName() == "AArch64" || Target.getName() == "ARM64") {
-    std::string PredicateNamespace = std::string(Target.getName());
-    if (PredicateNamespace == "Thumb")
-      PredicateNamespace = "ARM";
-
-    EmitDecoder(Records, OS, PredicateNamespace, "if (!Check(S, ", "))", "S",
-                "MCDisassembler::Fail",
-                "  MCDisassembler::DecodeStatus S = "
-                "MCDisassembler::Success;\n(void)S;");
-    return;
-  }
-
-  EmitDecoder(Records, OS, std::string(Target.getName()), "if (",
-              " == MCDisassembler::Fail)", "MCDisassembler::Success",
-              "MCDisassembler::Fail", "");
+  EmitDecoder(Records, OS, Target, Action);
 }
 
 } // end namespace llvm

llvm/utils/TableGen/TableGen.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/TableGen/Main.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/SetTheory.h"
 
 using namespace llvm;
 
-enum ActionType {
-  PrintRecords,
-  PrintDetailedRecords,
-  NullBackend,
-  DumpJSON,
-  GenEmitter,
-  GenRegisterInfo,
-  GenInstrInfo,
-  GenInstrDocs,
-  GenAsmWriter,
-  GenAsmMatcher,
-  GenDisassembler,
-  GenPseudoLowering,
-  GenCompressInst,
-  GenCallingConv,
-  GenDAGISel,
-  GenDFAPacketizer,
-  GenFastISel,
-  GenSubtarget,
-  GenIntrinsicEnums,
-  GenIntrinsicImpl,
-  PrintEnums,
-  PrintSets,
-  GenOptParserDefs,
-  GenOptRST,
-  GenCTags,
-  GenAttributes,
-  GenSearchableTables,
-  GenGlobalISel,
-  GenGICombiner,
-  GenX86EVEX2VEXTables,
-  GenX86FoldTables,
-  GenX86MnemonicTables,
-  GenRegisterBank,
-  GenExegesis,
-  GenAutomata,
-  GenDirectivesEnumDecl,
-  GenDirectivesEnumImpl,
-  GenDXILOperation,
-};
-
 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::Hidden, cl::init(true));
 } // end namespace llvm
cl::values(
                    "Generate instruction descriptions"),
         clEnumValN(GenInstrDocs, "gen-instr-docs",
                    "Generate instruction documentation"),
         clEnumValN(GenCallingConv, "gen-callingconv",
                    "Generate calling convention descriptions"),
         clEnumValN(GenAsmWriter, "gen-asm-writer", "Generate assembly writer"),
         clEnumValN(GenDisassembler, "gen-disassembler",
                    "Generate disassembler"),
+        clEnumValN(GenCapstone, "gen-capstone",
+                   "Generate disassembler for Capstone"),
         clEnumValN(GenPseudoLowering, "gen-pseudo-lowering",
                    "Generate pseudo instruction lowering"),
         clEnumValN(GenCompressInst, "gen-compress-inst-emitter",
                    "Generate RISCV compressed instructions."),
         clEnumValN(GenAsmMatcher, "gen-asm-matcher",
                    "Generate assembly instruction matcher"),
         clEnumValN(GenDAGISel, "gen-dag-isel",
                    "Generate a DAG instruction selector"),

 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 PrintRecords:
-    OS << Records;              // No argument, dump all contents
+    OS << Records; // No argument, dump all contents
     break;
   case PrintDetailedRecords:
     EmitDetailedRecords(Records, OS);
     break;
-  case NullBackend:             // No backend at all.
+  case NullBackend: // No backend at all.
     break;
   case DumpJSON:
     EmitJSON(Records, OS);
     break;
   case GenEmitter:
     EmitCodeEmitter(Records, OS);
     break;
   case GenRegisterInfo:
case GenCallingConv:
     EmitCallingConv(Records, OS);
     break;
   case GenAsmWriter:
     EmitAsmWriter(Records, OS);
     break;
   case GenAsmMatcher:
     EmitAsmMatcher(Records, OS);
     break;
+  case GenCapstone:
   case GenDisassembler:
-    EmitDisassembler(Records, OS);
+    EmitDisassembler(Records, OS, Action);
     break;
   case GenPseudoLowering:
     EmitPseudoLowering(Records, OS);
     break;
   case GenCompressInst:
     EmitCompressInst(Records, OS);
     break;
   case GenDAGISel:
case GenIntrinsicImpl:
     EmitIntrinsicImpl(Records, OS);
     break;
   case GenOptParserDefs:
     EmitOptParser(Records, OS);
     break;
   case GenOptRST:
     EmitOptRST(Records, OS);
     break;
-  case PrintEnums:
-  {
+  case PrintEnums: {
     for (Record *Rec : Records.getAllDerivedDefinitions(Class))
       OS << Rec->getName() << ", ";
     OS << "\n";
     break;
   }
-  case PrintSets:
-  {
+  case PrintSets: {
     SetTheory Sets;
     Sets.addFieldExpander("Set", "Elements");
     for (Record *Rec : Records.getAllDerivedDefinitions("Set")) {
       OS << Rec->getName() << " = [";
-      const std::vector<Record*> *Elts = Sets.expand(Rec);
+      const std::vector<Record *> *Elts = Sets.expand(Rec);
       assert(Elts && "Couldn't expand Set instance");
       for (Record *Elt : *Elts)
         OS << ' ' << Elt->getName();
       OS << " ]\n";
     }
     break;
   }
   case GenCTags:
case GenDirectivesEnumImpl:
     break;
   case GenDXILOperation:
     EmitDXILOperation(Records, OS);
     break;
   }
 
   return false;
 }
-}
+} // namespace
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv);
 
   return TableGenMain(argv[0], &LLVMTableGenMain);
 }
 

llvm/utils/TableGen/TableGenBackends.h

 // anything that they transitively depend on) causes everything dependent
 // on TableGen to be rebuilt (this includes all the targets!). Perhaps have
 // a standalone TableGen binary and have the backends be loadable modules
 // of some sort; then the dependency could be expressed as being on the
 // module, and all the modules would have a common dependency on the
 // TableGen binary with as few dependencies as possible on the rest of
 // LLVM.
 
+enum ActionType {
+  PrintRecords,
+  PrintDetailedRecords,
+  NullBackend,
+  DumpJSON,
+  GenEmitter,
+  GenRegisterInfo,
+  GenInstrInfo,
+  GenInstrDocs,
+  GenAsmWriter,
+  GenAsmMatcher,
+  GenDisassembler,
+  GenPseudoLowering,
+  GenCompressInst,
+  GenCallingConv,
+  GenDAGISel,
+  GenDFAPacketizer,
+  GenFastISel,
+  GenSubtarget,
+  GenIntrinsicEnums,
+  GenIntrinsicImpl,
+  PrintEnums,
+  PrintSets,
+  GenOptParserDefs,
+  GenOptRST,
+  GenCTags,
+  GenAttributes,
+  GenSearchableTables,
+  GenGlobalISel,
+  GenGICombiner,
+  GenX86EVEX2VEXTables,
+  GenX86FoldTables,
+  GenX86MnemonicTables,
+  GenRegisterBank,
+  GenExegesis,
+  GenAutomata,
+  GenDirectivesEnumDecl,
+  GenDirectivesEnumImpl,
+  GenDXILOperation,
+  GenCapstone,
+};
 
 namespace llvm {
 
 class raw_ostream;
 class RecordKeeper;
 
 void EmitIntrinsicEnums(RecordKeeper &RK, raw_ostream &OS);
 void EmitIntrinsicImpl(RecordKeeper &RK, raw_ostream &OS);
 void EmitAsmMatcher(RecordKeeper &RK, raw_ostream &OS);
 void EmitAsmWriter(RecordKeeper &RK, raw_ostream &OS);
 void EmitCallingConv(RecordKeeper &RK, raw_ostream &OS);
 void EmitCodeEmitter(RecordKeeper &RK, raw_ostream &OS);
 void EmitDAGISel(RecordKeeper &RK, raw_ostream &OS);
 void EmitDFAPacketizer(RecordKeeper &RK, raw_ostream &OS);
-void EmitDisassembler(RecordKeeper &RK, raw_ostream &OS);
+void EmitDisassembler(RecordKeeper &RK, raw_ostream &OS, ActionType AT);
 void EmitFastISel(RecordKeeper &RK, raw_ostream &OS);
 void EmitInstrInfo(RecordKeeper &RK, raw_ostream &OS);
 void EmitInstrDocs(RecordKeeper &RK, raw_ostream &OS);
 void EmitPseudoLowering(RecordKeeper &RK, raw_ostream &OS);
 void EmitCompressInst(RecordKeeper &RK, raw_ostream &OS);
 void EmitRegisterInfo(RecordKeeper &RK, raw_ostream &OS);
 void EmitSubtarget(RecordKeeper &RK, raw_ostream &OS);
 void EmitMapTable(RecordKeeper &RK, raw_ostream &OS);