GlobalISel: WIP: allow excluding of combine rules or groups

[aemerson]

Summary

I thought I needed this feature to disable a specific combine that was causing issues, but in the end changed my mind. However, it might still be useful for others. Putting it here in case anyone wants to take it over, add tests and use it.

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

 //
 //===----------------------------------------------------------------------===//
 
 // Common base class for GICombineRule and GICombineGroup.
 class GICombine {
   // See GICombineGroup. We only declare it here to make the tablegen pass
   // simpler.
   list<GICombine> Rules = ?;
+  list<GICombine> Excluded = ?;
 }
 
 // A group of combine rules that can be added to a GICombiner or another group.
-class GICombineGroup<list<GICombine> rules> : GICombine {
+class GICombineGroup<list<GICombine> rules, list<GICombine> excluded_rules = []> : GICombine {
   // The rules contained in this group. The rules in a group are flattened into
   // a single list and sorted into whatever order is most efficient. However,
   // they will never be re-ordered such that behaviour differs from the
   // specified order. It is therefore possible to use the order of rules in this
   // list to describe priorities.
   let Rules = rules;
+  // The excluded rules are deleted from the Rules list.
+  let Excluded = excluded_rules;
 }
 
 class GICombinerHelperArg<string type, string name> {
   string Type = type;
   string Name = name;
 }
 
 // Declares a combiner helper class
-class GICombinerHelper<string classname, list<GICombine> rules>
-    : GICombineGroup<rules> {
+class GICombinerHelper<string classname, list<GICombine> rules, list<GICombine> excluded = []>
+    : GICombineGroup<rules, excluded> {
   // The class name to use in the generated output.
   string Classname = classname;
   // The name of a run-time compiler option that will be generated to disable
   // specific rules within this combiner.
   string DisableRuleOption = ?;
   // The state class to inherit from (if any). The generated helper will inherit
   // from this class and will forward arguments to its constructors.
   string StateClass = "";

llvm/lib/Target/AArch64/AArch64Combine.td

 def fconstant_to_constant : GICombineRule<
   (defs root:$root),
   (match (wip_match_opcode G_FCONSTANT):$root,
          [{ return matchFConstantToConstant(*${root}, MRI); }]),
   (apply [{ applyFConstantToConstant(*${root}); }])>;
 
 def AArch64PreLegalizerCombinerHelper: GICombinerHelper<
   "AArch64GenPreLegalizerCombinerHelper", [all_combines,
-                                           fconstant_to_constant]> {
+                                           fconstant_to_constant],
+                                          []> {
   let DisableRuleOption = "aarch64prelegalizercombiner-disable-rule";
   let StateClass = "AArch64PreLegalizerCombinerHelperState";
   let AdditionalArguments = [];
 }
 
 // Matchdata for combines which replace a G_SHUFFLE_VECTOR with a
 // target-specific opcode.
 def shuffle_matchdata : GIDefMatchData<"ShuffleVectorPseudo">;

llvm/utils/TableGen/GICombinerEmitter.cpp

 //===- GlobalCombinerEmitter.cpp - Generate a combiner --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file Generate a combiner implementation for GlobalISel from a declarative
 /// syntax
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/StringMatcher.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include "CodeGenTarget.h"
 #include "GlobalISel/CodeExpander.h"
 #include "GlobalISel/CodeExpansions.h"
 #include "GlobalISel/GIMatchDag.h"
 #include "GlobalISel/GIMatchTree.h"
 #include <cstdint>
+#include <unordered_set>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "gicombiner-emitter"
 
 // FIXME: Use ALWAYS_ENABLED_STATISTIC once it's available.
 unsigned NumPatternTotal = 0;
 STATISTIC(NumPatternTotalStatistic, "Total number of patterns");
bool CombineRule::parseMatcher(const CodeGenTarget &Target) {
   }
   return true;
 }
 
 class GICombinerEmitter {
   StringRef Name;
   const CodeGenTarget &Target;
   Record *Combiner;
-  std::vector<std::unique_ptr<CombineRule>> Rules;
+  using RuleList = std::vector<std::unique_ptr<CombineRule>>;
+  RuleList Rules;
   GIMatchDagContext MatchDagCtx;
 
   std::unique_ptr<CombineRule> makeCombineRule(const Record &R);
 
-  void gatherRules(std::vector<std::unique_ptr<CombineRule>> &ActiveRules,
+  void gatherExcludedRules(std::unordered_set<std::string> &ExcludedNames,
+                           const std::vector<Record *> &RulesAndGroups);
+  void gatherRules(RuleList &ActiveRules,
+                   std::unordered_set<std::string> &ExcludedNames,
                    const std::vector<Record *> &&RulesAndGroups);
 
 public:
   explicit GICombinerEmitter(RecordKeeper &RK, const CodeGenTarget &Target,
                              StringRef Name, Record *Combiner);
   ~GICombinerEmitter() {}
 
   StringRef getClassName() const {
GICombinerEmitter::makeCombineRule(const Record &TheDef) {
   if (Rule->getNumRoots() > 1) {
     PrintError(TheDef.getLoc(), "Multi-root matches are not supported (yet)");
     return nullptr;
   }
   return Rule;
 }
 
 /// Recurse into GICombineGroup's and flatten the ruleset into a simple list.
-void GICombinerEmitter::gatherRules(
-    std::vector<std::unique_ptr<CombineRule>> &ActiveRules,
+void GICombinerEmitter::gatherExcludedRules(
+    std::unordered_set<std::string> &ExcludedRules,
+    const std::vector<Record *> &RulesAndGroups) {
+  for (Record *R : RulesAndGroups) {
+
+    if (R->isValueUnset("Excluded")) {
+      ExcludedRules.insert(std::string(R->getName()));
+    } else {
+      // Delete rules form the list in the excluded list.
+      auto Excluded = R->getValueAsListOfDefs("Excluded");
+      gatherExcludedRules(ExcludedRules, Excluded);
+    }
+  }
+  for (std::string s : ExcludedRules) {
+    LLVM_DEBUG(dbgs() << "Excluding rule: " << s << "\n");
+  }
+}
+
+/// Recurse into GICombineGroup's and flatten the ruleset into a simple list.
+void GICombinerEmitter::gatherRules(RuleList &ActiveRules,
+                                    std::unordered_set<std::string> &ExcludedNames,
     const std::vector<Record *> &&RulesAndGroups) {
   for (Record *R : RulesAndGroups) {
     if (R->isValueUnset("Rules")) {
       std::unique_ptr<CombineRule> Rule = makeCombineRule(*R);
       if (Rule == nullptr) {
         PrintError(R->getLoc(), "Failed to parse rule");
         continue;
       }
+      if (ExcludedNames.count(std::string(R->getName())))
+        continue;
       ActiveRules.emplace_back(std::move(Rule));
       ++NumPatternTotal;
-    } else
-      gatherRules(ActiveRules, R->getValueAsListOfDefs("Rules"));
+    } else {
+      gatherRules(ActiveRules, ExcludedNames, R->getValueAsListOfDefs("Rules"));
+    }
   }
 }
 
 void GICombinerEmitter::generateCodeForTree(raw_ostream &OS,
                                             const GIMatchTree &Tree,
                                             StringRef Indent) const {
   if (Tree.getPartitioner() != nullptr) {
     Tree.getPartitioner()->generatePartitionSelectorCode(OS, Indent);

 
 static void emitAdditionalHelperMethodArguments(raw_ostream &OS,
                                                 Record *Combiner) {
   for (Record *Arg : Combiner->getValueAsListOfDefs("AdditionalArguments"))
     OS << ",\n    " << Arg->getValueAsString("Type")
        << Arg->getValueAsString("Name");
 }
 
-void GICombinerEmitter::run(raw_ostream &OS) {
-  gatherRules(Rules, Combiner->getValueAsListOfDefs("Rules"));
+void GICombinerEmitter::run(raw_ostream & OS) {
+  std::unordered_set<std::string> ExcludedRules;
+  gatherExcludedRules(ExcludedRules,
+                      Combiner->getValueAsListOfDefs("Excluded"));
+  gatherRules(Rules, ExcludedRules, Combiner->getValueAsListOfDefs("Rules"));
+
   if (StopAfterParse) {
     MatchDagCtx.print(errs());
     PrintNote(Combiner->getLoc(),
               "Terminating due to -gicombiner-stop-after-parse");
     return;
   }
   if (ErrorsPrinted)
     PrintFatalError(Combiner->getLoc(), "Failed to parse one or more rules");