[gicombiner] Add support for arbitrary C++ predicates

[dsanders]

Summary

Add the ability to declare arbitrary C++ predicates and use them within a
matcher.

llvm/include/llvm/Target/GlobalISel/Combine.td

class GICombinerHelper<string classname, list<GICombine> rules>
   string Classname = classname;
   // The name of a run-time compiler option that will be generated to disable
   // specific rules within this combiner.
   string DisableRuleOption = ?;
 }
 class GICombineRule<dag defs, dag match, dag apply> : GICombine {
   /// Defines the external interface of the match rule. This includes:
   /// * The names of the root nodes (requires at least one)
+  /// * The names of any immediate operands.
+  /// * The names of any complex operands.
+  /// * Any macro substitutions/alternatives that should apply to this rule.
   /// See GIDefKind for details.
   dag Defs = defs;
 
   /// Defines the things which must be true for the pattern to match
   /// See GIMatchKind for details.
   dag Match = match;
 
   /// Defines the things which happen after the decision is made to apply a
   /// combine rule.
   /// See GIApplyKind for details.
   dag Apply = apply;
 }
 
+class GIType<string cxxType> {
+  string CxxType = cxxType;
+}
+def machineinstr : GIType<"MachineInstr&">;
+def machineoperand : GIType<"MachineOperand&">;
+
 /// The operator at the root of a GICombineRule.Defs dag.
 def defs;
 
 /// All arguments of the defs operator must be subclasses of GIDefKind or
 /// sub-dags whose operator is GIDefKindWithArgs.
 class GIDefKind;
 class GIDefKindWithArgs;
 /// Declare a root node. There must be at least one of these in every combine

 /// that occur multiple times introduce edges.
 class GIMatchKind;
 class GIMatchKindWithArgs;
 
 /// In lieu of having proper macro support. Trivial one-off opcode checks can be
 /// performed with this.
 def wip_match_opcode : GIMatchKindWithArgs;
 
+class GIMatchPredicate<string returnType, dag arguments, dag results,
+                       code predicate> : GIMatchKindWithArgs {
+  string ReturnType = returnType;
+  dag Arguments = arguments;
+  dag Results = results;
+  code Predicate = predicate;
+}
+def is_same_valid_type : GIMatchPredicate<
+    "bool", (ins machineoperand:$A, machineoperand:$B), (outs), [{
+  if (!${A}.isReg() || !${B}.isReg())
+    return false;
+  LLT ATy = MRI->getType(${A}.getReg());
+  LLT BTy = MRI->getType(${B}.getReg());
+  return ATy.isValid() && BTy.isValid() && ATy == BTy;
+}]>;
+
 /// The operator at the root of a GICombineRule.Apply dag.
 def apply;
 /// All arguments of the apply operator must be subclasses of GIApplyKind, or
 /// sub-dags whose operator is GIApplyKindWithArgs, or an MIR block
 /// (deprecated).
 class GIApplyKind;
 class GIApplyKindWithArgs;
 
 def copy_prop : GICombineRule<
-  (defs root:$d),
-  (match (COPY $d, $s):$mi,
-         [{ return Helper.matchCombineCopy(*${mi}); }]),
-  (apply [{ Helper.applyCombineCopy(*${mi}); }])>;
+  (defs root:$root),
+  (match (COPY $d, $s):$root,
+         (is_same_valid_type $d, $s),
+         [{ return Helper.matchCombineCopy(*${root}); }]),
+  (apply [{ Helper.applyCombineCopy(*${root}); }])>;
 def trivial_combines : GICombineGroup<[copy_prop]>;
 
 def extending_loads : GICombineRule<
   (defs root:$root, extending_load_matchdata:$matchinfo),
   (match (wip_match_opcode G_LOAD, G_SEXTLOAD, G_ZEXTLOAD):$root,
          [{ return Helper.matchCombineExtendingLoads(*${root}, ${matchinfo}); }]),
   (apply [{ Helper.applyCombineExtendingLoads(*${root}, ${matchinfo}); }])>;
 def combines_for_extload: GICombineGroup<[extending_loads]>;

llvm/utils/TableGen/GICombinerEmitter.cpp

 unsigned NumPatternTotal = 0;
 STATISTIC(NumPatternTotalStatistic, "Total number of patterns");
 
 cl::OptionCategory
     GICombinerEmitterCat("Options for -gen-global-isel-combiner");
 static cl::list<std::string>
     SelectedCombiners("combiners", cl::desc("Emit the specified combiners"),
                       cl::cat(GICombinerEmitterCat), cl::CommaSeparated);
-static cl::opt<bool> ShowExpansions(
+cl::opt<bool> ShowExpansions(
     "gicombiner-show-expansions",
     cl::desc("Use C++ comments to indicate occurence of code expansion"),
     cl::cat(GICombinerEmitterCat));
 static cl::opt<bool> StopAfterParse(
     "gicombiner-stop-after-parse",
     cl::desc("Stop processing after parsing rules and dump state"),
     cl::cat(GICombinerEmitterCat));
 static cl::opt<bool> StopAfterBuild(
struct VarInfo {
     const DagInit *Matcher;
 
   public:
     VarInfo(const GIMatchDagInstr *N, const GIMatchDagOperand *Op,
             const DagInit *Matcher)
         : N(N), Op(Op), Matcher(Matcher) {}
   };
 
+  struct PredInfo {
+    const GIMatchDagPredicate *P;
+    const GIMatchDagOperand *Op;
+
+  public:
+    PredInfo(const GIMatchDagPredicate *P, const GIMatchDagOperand *Op)
+        : P(P), Op(Op) {}
+  };
+
 protected:
   /// A unique ID for this rule
   /// ID's are used for debugging and run-time disabling of rules among other
   /// things.
   RuleID ID;
 
   /// A unique ID that can be used for anonymous objects belonging to this rule.
   /// Used to create unique names in makeNameForAnon*() without making tests
void declareMatchData(StringRef PatternSymbol, StringRef Type,
                         StringRef VarName);
 
   bool parseInstructionMatcher(const CodeGenTarget &Target, StringInit *ArgName,
                                const Init &Arg,
                                StringMap<std::vector<VarInfo>> &NamedEdgeDefs,
                                StringMap<std::vector<VarInfo>> &NamedEdgeUses);
   bool parseWipMatchOpcodeMatcher(const CodeGenTarget &Target,
                                   StringInit *ArgName, const Init &Arg);
+  bool parseMatchPredicateMatcher(
+      const CodeGenTarget &Target, StringInit *ArgName, const Init &Arg,
+      StringMap<std::vector<PredInfo>> &PredicateDepsByName);
 
 public:
   CombineRule(const CodeGenTarget &Target, GIMatchDagContext &Ctx, RuleID ID,
               const Record &R)
       : ID(ID), TheDef(R), MatchDag(Ctx) {}
   CombineRule(const CombineRule &) = delete;
 
   bool parseDefs();
if (const DagInit *Matcher =
     auto &Instr =
         Target.getInstruction(Matcher->getOperatorAsDef(TheDef.getLoc()));
 
     StringRef Name = ArgName ? ArgName->getValue() : "";
 
     GIMatchDagInstr *N =
         MatchDag.addInstrNode(makeDebugName(*this, Name), insertStrTab(Name),
                               MatchDag.getContext().makeOperandList(Instr));
+    if (find_if(Roots, [&](const RootInfo &X) {
+          return ArgName && X.getPatternSymbol() == ArgName->getValue();
+        }) != Roots.end()) {
+      N->setMatchRoot();
+    }
 
     N->setOpcodeAnnotation(&Instr);
     const auto &P = MatchDag.addPredicateNode<GIMatchDagOpcodePredicate>(
         makeNameForAnonPredicate(*this), Instr);
     MatchDag.addPredicateDependency(N, nullptr, P, &P->getOperandInfo()["mi"]);
     unsigned OpIdx = 0;
     for (const auto &NameInit : Matcher->getArgNames()) {
       StringRef Name = insertStrTab(NameInit->getAsUnquotedString());
for (const auto &Arg : Matcher->getArgs()) {
       PrintError(TheDef.getLoc(),
                  "Arguments to wip_match_opcode must be instructions");
       return false;
     }
     return true;
   }
   return false;
 }
+
+bool CombineRule::parseMatchPredicateMatcher(
+    const CodeGenTarget &Target, StringInit *ArgName, const Init &Arg,
+    StringMap<std::vector<PredInfo>> &PredicateDepsByName) {
+  if (const DagInit *Matcher =
+          getDagWithOperatorOfSubClass(Arg, "GIMatchPredicate")) {
+    const Record *PredDef = Matcher->getOperatorAsDef(TheDef.getLoc());
+
+    auto *P = MatchDag.addPredicateNode<GIMatchDagArbitraryCxxPredicate>(
+        makeNameForAnonPredicate(*this), *PredDef);
+
+    DagInit *PredicateArgs = PredDef->getValueAsDag("Arguments");
+    DagInit *PredicateResults = PredDef->getValueAsDag("Results");
+
+    if (PredicateArgs->getNumArgs() + PredicateResults->getNumArgs() != Matcher->getNumArgs()) {
+      PrintError(TheDef.getLoc(), "Unexpected number of operands, received " +
+                                      llvm::to_string(Matcher->getNumArgs()));
+      PrintNote(PredDef->getLoc(),
+                "but expected " +
+                    llvm::to_string(PredicateArgs->getNumArgs() +
+                                    PredicateResults->getNumArgs()));
+      return false;
+    }
+
+    if (PredicateResults->getNumArgs() > 0) {
+      llvm_unreachable("Not implemented");
+      return false;
+    }
+
+    // Each argument is an argument to the predicate. Add a dependency for each
+    // one that references something in the DAG.
+    for (unsigned I = 0; I < Matcher->getNumArgs(); ++I) {
+      StringRef VarName = Matcher->getArgName(I)->getValue();
+      PredicateDepsByName.try_emplace(VarName);
+      PredicateDepsByName[VarName].emplace_back(P, &P->getOperandInfo()[I]);
+      P->bind(VarName);
+    }
+    return true;
+  }
+  return false;
+}
+
 bool CombineRule::parseMatcher(const CodeGenTarget &Target) {
   NamedRegionTimer T("parseMatcher", "Time spent parsing the matcher",
                      "Rule Parsing", "Time spent on rule parsing", TimeRegions);
   StringMap<std::vector<VarInfo>> NamedEdgeDefs;
   StringMap<std::vector<VarInfo>> NamedEdgeUses;
+  StringMap<std::vector<PredInfo>> PredicateDepsByName;
   DagInit *Matchers = TheDef.getValueAsDag("Match");
 
   if (Matchers->getOperatorAsDef(TheDef.getLoc())->getName() != "match") {
     PrintError(TheDef.getLoc(), "Expected match operator");
     return false;
   }
 
   if (Matchers->getNumArgs() == 0) {
     PrintError(TheDef.getLoc(), "Matcher is empty");
     return false;
   }
 
   // The match section consists of a list of matchers and predicates. Parse each
   // one and add the equivalent GIMatchDag nodes, predicates, and edges.
   for (unsigned I = 0; I < Matchers->getNumArgs(); ++I) {
     if (parseInstructionMatcher(Target, Matchers->getArgName(I),
                                 *Matchers->getArg(I), NamedEdgeDefs,
                                 NamedEdgeUses))
       continue;
 
     if (parseWipMatchOpcodeMatcher(Target, Matchers->getArgName(I),
                                    *Matchers->getArg(I)))
       continue;
 
+    if (parseMatchPredicateMatcher(Target, Matchers->getArgName(I),
+                                   *Matchers->getArg(I),
+                                   PredicateDepsByName))
+      continue;
 
     // Parse arbitrary C++ code we have in lieu of supporting MIR matching
     if (const CodeInit *CodeI = dyn_cast<CodeInit>(Matchers->getArg(I))) {
       assert(!MatchingFixupCode &&
              "Only one block of arbitrary code is currently permitted");
       MatchingFixupCode = CodeI;
       MatchDag.setHasPostMatchPredicate(true);
       continue;
for (const VarInfo &DefVar : NameAndDefs.getValue()) {
         MatchDag.addEdge(insertStrTab(NameAndDefs.getKey()), UseVar.N, UseVar.Op,
                          DefVar.N, DefVar.Op);
       }
     }
   }
   if (FailedToAddEdges)
     return false;
 
+  // Add the dependencies from variables to predicates.
+  for (const auto &PredNameAndDeps : PredicateDepsByName) {
+    StringRef VarName = PredNameAndDeps.getKey();
+    FailedToAddEdges = true;
+    for (const PredInfo &P : PredNameAndDeps.getValue()) {
+      for (const VarInfo &UseVar : NamedEdgeUses[VarName]) {
+        MatchDag.addPredicateDependency(UseVar.N, UseVar.Op, P.P, P.Op);
+        FailedToAddEdges = false;
+      }
+      for (const VarInfo &DefVar : NamedEdgeDefs[VarName]) {
+        MatchDag.addPredicateDependency(DefVar.N, DefVar.Op, P.P, P.Op);
+        FailedToAddEdges = false;
+      }
+    }
+    if (FailedToAddEdges) {
+      PrintError(TheDef.getLoc(), "Undefined variable " + VarName);
+      return false;
+    }
+  }
+
   // If a variable is referenced in multiple use contexts then we need a
   // predicate to confirm they are the same operand. We can elide this if it's
   // also referenced in a def context and we're traversing the def-use chain
   // from the def to the uses but we can't know which direction we're going
   // until after reorientToRoots().
   for (const auto &NameAndUses : NamedEdgeUses) {
     const auto &Uses = NameAndUses.getValue();
     if (Uses.size() > 1) {
StringRef getClassName() const {
     return Combiner->getValueAsString("Classname");
   }
   void run(raw_ostream &OS);
 
   /// Emit the name matcher (guarded by #ifndef NDEBUG) used to disable rules in
   /// response to the generated cl::opt.
   void emitNameMatcher(raw_ostream &OS) const;
 
-  void generateDeclarationsCodeForTree(raw_ostream &OS, const GIMatchTree &Tree) const;
+  void generateDeclarationsCodeForTree(raw_ostream &HeaderOS,
+                                       raw_ostream &BodyOS,
+                                       const GIMatchTree &Tree) const;
   void generateCodeForTree(raw_ostream &OS, const GIMatchTree &Tree,
                            StringRef Indent) const;
 };
 
 GICombinerEmitter::GICombinerEmitter(RecordKeeper &RK,
                                      const CodeGenTarget &Target,
                                      StringRef Name, Record *Combiner)
     : Name(Name), Target(Target), Combiner(Combiner) {}
if (R->isValueUnset("Rules")) {
       }
       ActiveRules.emplace_back(std::move(Rule));
       ++NumPatternTotal;
     } else
       gatherRules(ActiveRules, R->getValueAsListOfDefs("Rules"));
   }
 }
 
+void GICombinerEmitter::generateDeclarationsCodeForTree(
+    raw_ostream &HeaderOS, raw_ostream &BodyOS, const GIMatchTree &Tree) const {
+  if (Tree.getPartitioner() != nullptr) {
+    for (const auto &Child : Tree.children())
+      generateDeclarationsCodeForTree(HeaderOS, BodyOS, Child);
+    return;
+  }
+
+  for (const auto &Leaf : Tree.possible_leaves())
+    for (const GIMatchDagPredicate *Predicate : Leaf.untested_predicates())
+      Predicate->generateDeclarationsCode(HeaderOS, BodyOS, getClassName());
+}
+
 void GICombinerEmitter::generateCodeForTree(raw_ostream &OS,
                                             const GIMatchTree &Tree,
                                             StringRef Indent) const {
   if (Tree.getPartitioner() != nullptr) {
     Tree.getPartitioner()->generatePartitionSelectorCode(OS, Indent);
     for (const auto &EnumChildren : enumerate(Tree.children())) {
       OS << Indent << "if (Partition == " << EnumChildren.index() << " /* "
          << format_partition_name(Tree, EnumChildren.index()) << " */) {\n";
NamedRegionTimer T("Emit", "Time spent emitting the combiner",
                      TimeRegions);
   OS << "#ifdef " << Name.upper() << "_GENCOMBINERHELPER_DEPS\n"
      << "#include \"llvm/ADT/SparseBitVector.h\"\n"
      << "namespace llvm {\n"
      << "extern cl::OptionCategory GICombinerOptionCategory;\n"
      << "} // end namespace llvm\n"
      << "#endif // ifdef " << Name.upper() << "_GENCOMBINERHELPER_DEPS\n\n";
 
+  std::string PredicatesHeader, PredicatesBody;
+  raw_string_ostream PredicatesHeaderOS(PredicatesHeader);
+  raw_string_ostream PredicatesBodyOS(PredicatesBody);
+  generateDeclarationsCodeForTree(PredicatesHeaderOS, PredicatesBodyOS, *Tree);
+
   OS << "#ifdef " << Name.upper() << "_GENCOMBINERHELPER_H\n"
      << "class " << getClassName() << " {\n"
      << "  SparseBitVector<> DisabledRules;\n"
      << "\n"
+     << PredicatesHeaderOS.str()
      << "public:\n"
      << "  bool parseCommandLineOption();\n"
      << "  bool isRuleDisabled(unsigned ID) const;\n"
      << "  bool setRuleDisabled(StringRef RuleIdentifier);\n"
      << "\n"
      << "  bool tryCombineAll(\n"
      << "    GISelChangeObserver &Observer,\n"
      << "    MachineInstr &MI,\n"
      << "    MachineIRBuilder &B,\n"
      << "    CombinerHelper &Helper) const;\n"
+     << "\n"
+     << "private:\n"
+     << "  /// These mutable fields are accessors set by the entry point for\n"
+     << "  /// use by the C++ predicates. They must be set by every try*()\n"
+     << "  /// entry point.\n"
+     << "\n"
+     << "  /// Parent MBB for the current MI being processed\n"
+     << "  mutable MachineBasicBlock *MBB = nullptr;\n"
+     << "  /// Parent MF for the current MI being processed\n"
+     << "  mutable MachineFunction *MF = nullptr;\n"
+     << "  /// MRI for the current MI being processed\n"
+     << "  mutable MachineRegisterInfo *MRI = nullptr;\n"
      << "};\n\n";
 
   emitNameMatcher(OS);
 
   OS << "bool " << getClassName()
      << "::setRuleDisabled(StringRef RuleIdentifier) {\n"
      << "  std::pair<StringRef, StringRef> RangePair = "
         "RuleIdentifier.split('-');\n"
OS << "#ifdef " << Name.upper() << "_GENCOMBINERHELPER_CPP\n"
      << "    cl::Hidden,\n"
      << "    cl::cat(GICombinerOptionCategory));\n"
      << "\n"
      << "bool " << getClassName() << "::parseCommandLineOption() {\n"
      << "  for (const auto &Identifier : " << Name << "Option)\n"
      << "    if (!setRuleDisabled(Identifier))\n"
      << "      return false;\n"
      << "  return true;\n"
-     << "}\n\n";
+     << "}\n\n"
+     << PredicatesBodyOS.str() << "\n\n";
+  OS << "\n";
 
   OS << "bool " << getClassName() << "::tryCombineAll(\n"
      << "    GISelChangeObserver &Observer,\n"
      << "    MachineInstr &MI,\n"
      << "    MachineIRBuilder &B,\n"
      << "    CombinerHelper &Helper) const {\n"
-     << "  MachineBasicBlock *MBB = MI.getParent();\n"
-     << "  MachineFunction *MF = MBB->getParent();\n"
-     << "  MachineRegisterInfo &MRI = MF->getRegInfo();\n"
+     << "  MBB = MI.getParent();\n"
+     << "  MF = MBB->getParent();\n"
+     << "  MRI = &MF->getRegInfo();\n"
      << "  SmallVector<MachineInstr *, 8> MIs = { &MI };\n\n"
      << "  (void)MBB; (void)MF; (void)MRI;\n\n";
 
   OS << "  // Match data\n";
   for (const auto &Rule : Rules)
     for (const auto &I : Rule->matchdata_decls())
       OS << "  " << I.getType() << " " << I.getVariableName() << ";\n";
   OS << "\n";

llvm/utils/TableGen/GlobalISel/GIMatchDag.h

 #define LLVM_UTILS_TABLEGEN_GIMATCHDAG_H
 
 #include "GIMatchDagEdge.h"
 #include "GIMatchDagInstr.h"
 #include "GIMatchDagOperands.h"
 #include "GIMatchDagPredicate.h"
 #include "GIMatchDagPredicateDependencyEdge.h"
 
+#include "llvm/TableGen/Record.h"
+
 namespace llvm {
 class GIMatchDag;
 
 /// This class manages lifetimes for data associated with the GIMatchDag object.
 class GIMatchDagContext {
   GIMatchDagOperandListContext OperandListCtx;
 
 public:
   const GIMatchDagOperandList &makeEmptyOperandList() {
     return OperandListCtx.makeEmptyOperandList();
   }
 
   const GIMatchDagOperandList &makeOperandList(const CodeGenInstruction &I) {
     return OperandListCtx.makeOperandList(I);
   }
 
   const GIMatchDagOperandList &makeMIPredicateOperandList() {
     return OperandListCtx.makeMIPredicateOperandList();
   }
 
+  const GIMatchDagOperandList &
+  makeGIMatchDagPredicateOperandList(const Record &TheDef) {
+    return OperandListCtx.makeGIMatchDagPredicateOperandList(TheDef);
+  }
 
   const GIMatchDagOperandList &makeTwoMOPredicateOperandList() {
     return OperandListCtx.makeTwoMOPredicateOperandList();
   }
 
   void print(raw_ostream &OS) const {
     OperandListCtx.print(OS);
   }

llvm/utils/TableGen/GlobalISel/GIMatchDagInstr.h

protected:
   bool IsMatchRoot = false;
 
 public:
   GIMatchDagInstr(GIMatchDag &Dag, StringRef Name, StringRef UserAssignedName,
                   const GIMatchDagOperandList &OperandInfo)
       : Dag(Dag), Name(Name), UserAssignedName(UserAssignedName),
         OperandInfo(OperandInfo) {}
 
+  const GIMatchDag &getDag() const { return Dag; }
   const GIMatchDagOperandList &getOperandInfo() const { return OperandInfo; }
   StringRef getName() const { return Name; }
   StringRef getUserAssignedName() const { return UserAssignedName; }
+  StringRef getUserAssignedNameForOperand(unsigned Idx) const {
+    return UserAssignedNamesForOperands.lookup(Idx);
+  }
+
   void assignNameToOperand(unsigned Idx, StringRef Name) {
     assert(UserAssignedNamesForOperands[Idx].empty() && "Cannot assign twice");
     UserAssignedNamesForOperands[Idx] = Name;
   }
 
   const_user_assigned_operand_names_iterator
   user_assigned_operand_names_begin() const {
     return UserAssignedNamesForOperands.begin();

llvm/utils/TableGen/GlobalISel/GIMatchDagOperands.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_UTILS_TABLEGEN_GIMATCHDAGOPERANDS_H
 #define LLVM_UTILS_TABLEGEN_GIMATCHDAGOPERANDS_H
 
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Config/llvm-config.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <vector>
 
 namespace llvm {
 class CodeGenInstruction;
+class Record;
+
 /// Describes an operand of a MachineInstr w.r.t the DAG Matching. This
 /// information is derived from CodeGenInstruction::Operands but is more
 /// readily available for context-less access as we don't need to know which
 /// instruction it's used with or know how many defs that instruction had.
 ///
 /// There may be multiple GIMatchDagOperand's with the same contents. However,
 /// they are uniqued within the set of instructions that have the same overall
 /// operand list. For example, given:
public:
   /// See FoldingSet for details.
   void Profile(FoldingSetNodeID &ID) const;
 
   iterator begin() { return Operands.begin(); }
   const_iterator begin() const { return Operands.begin(); }
   iterator end() { return Operands.end(); }
   const_iterator end() const { return Operands.end(); }
 
+  size_t size() const { return Operands.size(); }
+
   const value_type &operator[](unsigned I) const { return Operands[I]; }
   const value_type &operator[](StringRef K) const;
 
   void print(raw_ostream &OS) const;
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const { print(errs()); }
 #endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 };
 
 /// This is the portion of GIMatchDagContext that directly relates to
 /// GIMatchDagOperandList and GIMatchDagOperandList.
 class GIMatchDagOperandListContext {
   FoldingSet<GIMatchDagOperandList> OperandLists;
   std::vector<std::unique_ptr<GIMatchDagOperandList>> OperandListsOwner;
 
 public:
   const GIMatchDagOperandList &makeEmptyOperandList();
   const GIMatchDagOperandList &makeOperandList(const CodeGenInstruction &I);
   const GIMatchDagOperandList &makeMIPredicateOperandList();
+  const GIMatchDagOperandList &
+  makeGIMatchDagPredicateOperandList(const Record &TheDef);
   const GIMatchDagOperandList &makeTwoMOPredicateOperandList();
 
   void print(raw_ostream &OS) const;
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const { print(errs()); }
 #endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 };
 
 } // end namespace llvm
 #endif // ifndef LLVM_UTILS_TABLEGEN_GIMATCHDAGOPERANDS_H

llvm/utils/TableGen/GlobalISel/GIMatchDagOperands.cpp

 //===- GIMatchDagOperands.cpp - A shared operand list for nodes -----------===//
 //
 // 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 "GIMatchDagOperands.h"
 
 #include "../CodeGenInstruction.h"
+#include "llvm/TableGen/Record.h"
 
 using namespace llvm;
 
 void GIMatchDagOperand::Profile(FoldingSetNodeID &ID) const {
   Profile(ID, Idx, Name, IsDef);
 }
 
 void GIMatchDagOperand::Profile(FoldingSetNodeID &ID, size_t Idx,
std::unique_ptr<GIMatchDagOperandList> NewValue =
       std::make_unique<GIMatchDagOperandList>();
   NewValue->add("$", 0, true);
   NewValue->add("mi", 1, false);
   OperandLists.InsertNode(NewValue.get(), InsertPoint);
   OperandListsOwner.push_back(std::move(NewValue));
   return *OperandListsOwner.back().get();
 }
 
+const GIMatchDagOperandList &
+GIMatchDagOperandListContext::makeGIMatchDagPredicateOperandList(
+    const Record &TheDef) {
+  FoldingSetNodeID ID;
+  DagInit *PredicateArgs = TheDef.getValueAsDag("Arguments");
+  unsigned OpIdx = 0;
+  for (unsigned I = 0; I < PredicateArgs->getNumArgs(); ++I)
+    GIMatchDagOperand::Profile(ID, OpIdx++,
+                               PredicateArgs->getArgName(I)->getValue(), false);
+  DagInit *PredicateResults = TheDef.getValueAsDag("Results");
+  for (unsigned I = 0; I < PredicateResults->getNumArgs(); ++I)
+    GIMatchDagOperand::Profile(ID, OpIdx++,
+                               PredicateArgs->getArgName(I)->getValue(), true);
+
+  void *InsertPoint;
+  GIMatchDagOperandList *Value =
+      OperandLists.FindNodeOrInsertPos(ID, InsertPoint);
+  if (Value)
+    return *Value;
+
+  std::unique_ptr<GIMatchDagOperandList> NewValue =
+      std::make_unique<GIMatchDagOperandList>();
+  OpIdx = 0;
+  for (unsigned I = 0; I < PredicateArgs->getNumArgs(); ++I)
+    NewValue->add(PredicateArgs->getArgName(I)->getValue(), OpIdx++, false);
+  for (unsigned I = 0; I < PredicateResults->getNumArgs(); ++I)
+    NewValue->add(PredicateArgs->getArgName(I)->getValue(), OpIdx++, true);
+
+  OperandLists.InsertNode(NewValue.get(), InsertPoint);
+  OperandListsOwner.push_back(std::move(NewValue));
+  return *OperandListsOwner.back().get();
+}
 
 const GIMatchDagOperandList &
 GIMatchDagOperandListContext::makeTwoMOPredicateOperandList() {
   FoldingSetNodeID ID;
   GIMatchDagOperand::Profile(ID, 0, "$", true);
   GIMatchDagOperand::Profile(ID, 1, "mi0", false);
   GIMatchDagOperand::Profile(ID, 2, "mi1", false);
 

llvm/utils/TableGen/GlobalISel/GIMatchDagPredicate.h

 //===- GIMatchDagPredicate - Represent a predicate to check ---------------===//
 //
 // 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_GIMATCHDAGPREDICATE_H
 #define LLVM_UTILS_TABLEGEN_GIMATCHDAGPREDICATE_H
 
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "GIMatchDag.h"
 
 namespace llvm {
 class CodeExpansions;
 class CodeGenInstruction;
 class GIMatchDagOperandList;
 class GIMatchDagContext;
+class Record;
 class raw_ostream;
 
 /// Represents a predicate on the match DAG. This records the details of the
 /// predicate. The dependencies are stored in the GIMatchDag as edges.
 ///
 /// Instances of this class objects are owned by the GIMatchDag and are not
 /// shareable between instances of GIMatchDag.
 class GIMatchDagPredicate {
 public:
   enum GIMatchDagPredicateKind {
     GIMatchDagPredicateKind_Opcode,
     GIMatchDagPredicateKind_OneOfOpcodes,
     GIMatchDagPredicateKind_SameMO,
+    GIMatchDagPredicateKind_ArbitraryCxxPredicate,
   };
 
 protected:
   const GIMatchDagPredicateKind Kind;
 
   /// The name of the predicate. For example:
   ///     (FOO $a:s32, $b, $c)
   /// will cause 's32' to be assigned to this member for the $a predicate.
GIMatchDagPredicate(GIMatchDagPredicateKind Kind, StringRef Name,
       : Kind(Kind), Name(Name), OperandInfo(OperandInfo) {}
   virtual ~GIMatchDagPredicate() {}
 
   GIMatchDagPredicateKind getKind() const { return Kind; }
 
   StringRef getName() const { return Name; }
   const GIMatchDagOperandList &getOperandInfo() const { return OperandInfo; }
 
+  // Generate C++ code for declarations this predicate will need.
+  virtual void generateDeclarationsCode(raw_ostream &HeaderOS,
+                                        raw_ostream &BodyOS,
+                                        StringRef ClassName) const {}
+
   // Generate C++ code to check this predicate. If a partitioner has already
   // tested this predicate then this function won't be called. If this function
   // is called, it must emit code and return true to indicate that it did so. If
   // it ever returns false, then the caller will abort due to an untested
   // predicate.
   virtual bool generateCheckCode(raw_ostream &OS, StringRef Indent,
                                  const CodeExpansions &Expansions) const {
     return false;
public:
 
   void printDescription(raw_ostream &OS) const override;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   virtual LLVM_DUMP_METHOD void dump() const override { print(errs()); }
 #endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 };
 
+class GIMatchDagArbitraryCxxPredicate : public GIMatchDagPredicate {
+  const Record &TheDef;
+  SmallVector<StringRef, 2> Args;
+
+  static SmallPtrSet<const Record *, 32> Emitted;
+
+public:
+  GIMatchDagArbitraryCxxPredicate(GIMatchDagContext &Ctx, StringRef Name,
+                                  const Record &TheDef);
+
+  static bool classof(const GIMatchDagPredicate *P) {
+    return P->getKind() == GIMatchDagPredicateKind_ArbitraryCxxPredicate;
+  }
+
+  void bind(StringRef Name) { Args.push_back(Name); }
+
+  void generateDeclarationsCode(raw_ostream &HeaderOS, raw_ostream &BodyOS,
+                                StringRef ClassName) const override;
+  bool generateCheckCode(raw_ostream &OS, StringRef Indent,
+                         const CodeExpansions &Expansions) const override;
+
+  void printDescription(raw_ostream &OS) const override;
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  virtual LLVM_DUMP_METHOD void dump() const override { print(errs()); }
+#endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+};
+
 raw_ostream &operator<<(raw_ostream &OS, const GIMatchDagPredicate &N);
 raw_ostream &operator<<(raw_ostream &OS, const GIMatchDagOpcodePredicate &N);
+raw_ostream &operator<<(raw_ostream &OS, const GIMatchDagSameMOPredicate &N);
+raw_ostream &operator<<(raw_ostream &OS, const GIMatchDagArbitraryCxxPredicate &N);
 
 } // end namespace llvm
 #endif // ifndef LLVM_UTILS_TABLEGEN_GIMATCHDAGPREDICATE_H

llvm/utils/TableGen/GlobalISel/GIMatchDagPredicate.cpp

 //===- GIMatchDagPredicate.cpp - Represent a predicate to check -----------===//
 //
 // 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 "GIMatchDagPredicate.h"
 
+#include "llvm/Support/CommandLine.h"
+#include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
+#include "CodeExpansions.h"
+#include "CodeExpander.h"
 #include "GIMatchDagOperands.h"
 #include "../CodeGenInstruction.h"
 
 using namespace llvm;
 
+extern cl::opt<bool> ShowExpansions;
+
 void GIMatchDagPredicate::print(raw_ostream &OS) const {
   OS << "<<";
   printDescription(OS);
   OS << ">>:$" << Name;
 }
 
 void GIMatchDagPredicate::printDescription(raw_ostream &OS) const { OS << ""; }
 
GIMatchDagSameMOPredicate::GIMatchDagSameMOPredicate(GIMatchDagContext &Ctx,
                                                      StringRef Name)
     : GIMatchDagPredicate(GIMatchDagPredicateKind_SameMO, Name,
                           Ctx.makeTwoMOPredicateOperandList()) {}
 
 void GIMatchDagSameMOPredicate::printDescription(raw_ostream &OS) const {
   OS << "$mi0 == $mi1";
 }
 
+SmallPtrSet<const Record *, 32> GIMatchDagArbitraryCxxPredicate::Emitted = {};
+
+GIMatchDagArbitraryCxxPredicate::GIMatchDagArbitraryCxxPredicate(
+    GIMatchDagContext &Ctx, StringRef Name, const Record &TheDef)
+    : GIMatchDagPredicate(GIMatchDagPredicateKind_ArbitraryCxxPredicate, Name,
+                          Ctx.makeGIMatchDagPredicateOperandList(TheDef)),
+      TheDef(TheDef) {}
+
+void GIMatchDagArbitraryCxxPredicate::printDescription(raw_ostream &OS) const {
+  OS << "call predicate " << TheDef.getName() << "(";
+  OperandInfo.print(OS);
+  OS << ")";
+}
+
+void GIMatchDagArbitraryCxxPredicate::generateDeclarationsCode(
+    raw_ostream &HeaderOS, raw_ostream &BodyOS, StringRef ClassName) const {
+  if (!Emitted.count(&TheDef)) {
+    Emitted.insert(&TheDef);
+
+    HeaderOS << "  " << TheDef.getValueAsString("ReturnType") << " "
+             << "testPredicate_" << TheDef.getName() << "(";
+    BodyOS << TheDef.getValueAsString("ReturnType") << " " << ClassName
+           << "::testPredicate_" << TheDef.getName() << "(";
+
+    DagInit *Arguments = TheDef.getValueAsDag("Arguments");
+    CodeExpansions Expansions;
+    StringRef Separator = "";
+    for (unsigned i = 0; i < Arguments->getNumArgs(); ++i) {
+      DefInit *Arg = dyn_cast<DefInit>(Arguments->getArg(i));
+      if (!Arg || !Arg->getDef()->isSubClassOf("GIType")) {
+        PrintError(TheDef.getLoc(), "Expected subclass of GIType");
+        continue;
+      }
+      StringRef Type = Arg->getDef()->getValueAsString("CxxType");
+      StringRef Name = Arguments->getArgName(i)->getValue();
+      HeaderOS << Separator << Type << " " << Name;
+      BodyOS << Separator << Type << " " << Name;
+      Separator = ", ";
+
+      Expansions.declare(Name, Name);
+    }
+    HeaderOS << ") const;  \n";
+    BodyOS << ") const {\n  "
+           << CodeExpander(TheDef.getValueAsString("Predicate").trim(" \t\n"),
+                           Expansions, TheDef.getLoc(), ShowExpansions, "")
+           << "\n}\n";
+  }
+}
+
+bool GIMatchDagArbitraryCxxPredicate::generateCheckCode(
+    raw_ostream &OS, StringRef Indent, const CodeExpansions &Expansions) const {
+  OS << Indent << "&& testPredicate_" << TheDef.getName() << "(";
+  StringRef Separator = "";
+  for (StringRef Name : Args) {
+    OS << Separator << Expansions.lookup(Name);
+    Separator = ", ";
+  }
+  OS << ")\n";
+  return true;
+}
+
 raw_ostream &llvm::operator<<(raw_ostream &OS, const GIMatchDagPredicate &N) {
   N.print(OS);
   return OS;
 }
 
 raw_ostream &llvm::operator<<(raw_ostream &OS,
                               const GIMatchDagOpcodePredicate &N) {
   N.print(OS);
   return OS;
 }
+
+raw_ostream &llvm::operator<<(raw_ostream &OS,
+                              const GIMatchDagSameMOPredicate &N) {
+  N.print(OS);
+  return OS;
+}
+
+raw_ostream &llvm::operator<<(raw_ostream &OS,
+                              const GIMatchDagArbitraryCxxPredicate &N) {
+  N.print(OS);
+  return OS;
+}