[TableGen] Allow emitter actions to use const RecordKeeper &

- Refactor TableGen backend options to allow specifying an action
  function that takes a const reference to `RecordKeeper`. This
  will enable gradual migration of code to use const references
  and pointers to `RecordKeeper` and `Record` in the TableGen
  backend.

- Refactor handling of these action command line options. Split
  `Action` into 2 global variables `ActionConst` for actions that
  take a const reference and `ActionNonConst` for actions that
  take a non-const reference. Also move these variables from the
  header to the CPP file and added a function `ApplyAction` to
  apply one of these actions.

- Change some existing actions to take const reference.

- Change global variables in TableGen.cpp to be static instead of
  being in an anonymous namespace per LLVM coding standards.

Author: jurahul

llvm/include/llvm/TableGen/Record.h

@@ -1757,7 +1757,7 @@ class Record {
   ArrayRef<AssertionInfo> getAssertions() const { return Assertions; }
   ArrayRef<DumpInfo> getDumps() const { return Dumps; }
 
-  ArrayRef<std::pair<Record *, SMRange>>  getSuperClasses() const {
+  ArrayRef<std::pair<Record *, SMRange>> getSuperClasses() const {
     return SuperClasses;
   }
 

llvm/include/llvm/TableGen/TableGenBackend.h

@@ -14,8 +14,6 @@
 #define LLVM_TABLEGEN_TABLEGENBACKEND_H
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/TableGen/Record.h"
 
 namespace llvm {
@@ -24,20 +22,13 @@ class RecordKeeper;
 class raw_ostream;
 
 namespace TableGen::Emitter {
-using FnT = void (*)(RecordKeeper &Records, raw_ostream &OS);
-
-struct OptCreatorT {
-  static void *call();
-};
-
-extern ManagedStatic<cl::opt<FnT>, OptCreatorT> Action;
+// Support for const and non-const forms of action functions.
+using FnNonConstT = void (*)(RecordKeeper &Records, raw_ostream &OS);
+using FnConstT = void (*)(const RecordKeeper &Records, raw_ostream &OS);
 
 struct Opt {
-  Opt(StringRef Name, FnT CB, StringRef Desc, bool ByDefault = false) {
-    if (ByDefault)
-      Action->setInitialValue(CB);
-    Action->getParser().addLiteralOption(Name, CB, Desc);
-  }
+  Opt(StringRef Name, FnNonConstT CB, StringRef Desc, bool ByDefault = false);
+  Opt(StringRef Name, FnConstT CB, StringRef Desc, bool ByDefault = false);
 };
 
 template <class EmitterC> class OptClass : Opt {
@@ -47,6 +38,10 @@ template <class EmitterC> class OptClass : Opt {
   OptClass(StringRef Name, StringRef Desc) : Opt(Name, run, Desc) {}
 };
 
+/// Apply action specified on the command line. Returns false is an action
+/// was applied.
+bool ApplyAction(RecordKeeper &Records, raw_ostream &OS);
+
 } // namespace TableGen::Emitter
 
 /// emitSourceFileHeader - Output an LLVM style file header to the specified

llvm/lib/TableGen/Main.cpp

@@ -131,13 +131,10 @@ int llvm::TableGenMain(const char *argv0,
   std::string OutString;
   raw_string_ostream Out(OutString);
   unsigned status = 0;
-  TableGen::Emitter::FnT ActionFn = TableGen::Emitter::Action->getValue();
-  if (ActionFn)
-    ActionFn(Records, Out);
-  else if (MainFn)
-    status = MainFn(Out, Records);
-  else
-    return 1;
+  // ApplyAction will return true if it did not apply any action. In that case,
+  // attempt to apply the MainFn.
+  if (TableGen::Emitter::ApplyAction(Records, Out))
+    status = MainFn ? MainFn(Out, Records) : 1;
   Records.stopBackendTimer();
   if (status)
     return 1;

llvm/lib/TableGen/TableGenBackend.cpp

@@ -12,22 +12,67 @@
 
 #include "llvm/TableGen/TableGenBackend.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <variant>
 
 using namespace llvm;
+using namespace TableGen;
+using namespace Emitter;
 
 const size_t MAX_LINE_LEN = 80U;
 
-namespace llvm::TableGen::Emitter {
-ManagedStatic<cl::opt<FnT>, OptCreatorT> Action;
-void *OptCreatorT::call() {
-  return new cl::opt<FnT>(cl::desc("Action to perform:"));
+namespace {
+template <typename FnT> struct OptCreatorT {
+  static void *call() {
+    return new cl::opt<FnT>(cl::desc("Action to perform:"));
+  }
+};
+} // namespace
+
+// `ActionNonConst` and `ActionConst` will be initialized if the corresponding
+// option is seen on the command line. `DefaultAction` will be initialized to
+// the action function if an option is specified as default.
+static ManagedStatic<cl::opt<FnNonConstT>, OptCreatorT<FnNonConstT>>
+    ActionNonConst;
+static ManagedStatic<cl::opt<FnConstT>, OptCreatorT<FnConstT>> ActionConst;
+static std::variant<FnNonConstT, FnConstT> DefaultAction;
+
+Opt::Opt(StringRef Name, FnNonConstT CB, StringRef Desc, bool ByDefault) {
+  if (ByDefault)
+    DefaultAction = CB;
+  ActionNonConst->getParser().addLiteralOption(Name, CB, Desc);
+}
+
+Opt::Opt(StringRef Name, FnConstT CB, StringRef Desc, bool ByDefault) {
+  if (ByDefault)
+    DefaultAction = CB;
+  ActionConst->getParser().addLiteralOption(Name, CB, Desc);
+}
+
+/// Apply action specified on the command line. Returns false is an action
+/// was applied.
+bool llvm::TableGen::Emitter::ApplyAction(RecordKeeper &Records,
+                                          raw_ostream &OS) {
+  // Prioritize command line option if one if specified. If none was specified
+  // use the default action if one was specified.
+  if (auto Fn = ActionNonConst->getValue())
+    Fn(Records, OS);
+  else if (auto Fn = ActionConst->getValue())
+    Fn(Records, OS);
+  else if (auto *Fn = std::get_if<FnNonConstT>(&DefaultAction); Fn && *Fn)
+    (*Fn)(Records, OS);
+  else if (auto *Fn = std::get_if<FnConstT>(&DefaultAction); Fn && *Fn)
+    (*Fn)(Records, OS);
+  else
+    return true;
+  return false;
 }
-} // namespace llvm::TableGen::Emitter
 
 static void printLine(raw_ostream &OS, const Twine &Prefix, char Fill,
                       StringRef Suffix) {

llvm/utils/TableGen/DisassemblerEmitter.cpp

@@ -11,6 +11,7 @@
 #include "WebAssemblyDisassemblerEmitter.h"
 #include "X86DisassemblerTables.h"
 #include "X86RecognizableInstr.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"

llvm/utils/TableGen/IntrinsicEmitter.cpp

@@ -681,14 +681,14 @@ void IntrinsicEmitter::EmitIntrinsicToBuiltinMap(
   OS << "#endif\n\n";
 }
 
-static void EmitIntrinsicEnums(RecordKeeper &RK, raw_ostream &OS) {
+static void EmitIntrinsicEnums(const RecordKeeper &RK, raw_ostream &OS) {
   IntrinsicEmitter(RK).run(OS, /*Enums=*/true);
 }
 
 static TableGen::Emitter::Opt X("gen-intrinsic-enums", EmitIntrinsicEnums,
                                 "Generate intrinsic enums");
 
-static void EmitIntrinsicImpl(RecordKeeper &RK, raw_ostream &OS) {
+static void EmitIntrinsicImpl(const RecordKeeper &RK, raw_ostream &OS) {
   IntrinsicEmitter(RK).run(OS, /*Enums=*/false);
 }
 

llvm/utils/TableGen/TableGen.cpp

@@ -33,50 +33,47 @@ cl::opt<bool> EmitLongStrLiterals(
     cl::Hidden, cl::init(true));
 } // end namespace llvm
 
-namespace {
+static cl::OptionCategory PrintEnumsCat("Options for -print-enums");
+static cl::opt<std::string> Class("class",
+                                  cl::desc("Print Enum list for this class"),
+                                  cl::value_desc("class name"),
+                                  cl::cat(PrintEnumsCat));
 
-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));
-
-void PrintRecords(RecordKeeper &Records, raw_ostream &OS) {
+static void PrintRecords(const RecordKeeper &Records, raw_ostream &OS) {
   OS << Records; // No argument, dump all contents
 }
 
-void PrintEnums(RecordKeeper &Records, raw_ostream &OS) {
+static void PrintEnums(const RecordKeeper &Records, raw_ostream &OS) {
   for (Record *Rec : Records.getAllDerivedDefinitions(Class))
     OS << Rec->getName() << ", ";
   OS << "\n";
 }
 
-void PrintSets(RecordKeeper &Records, raw_ostream &OS) {
+static void PrintSets(const RecordKeeper &Records, raw_ostream &OS) {
   SetTheory Sets;
   Sets.addFieldExpander("Set", "Elements");
   for (Record *Rec : Records.getAllDerivedDefinitions("Set")) {
     OS << Rec->getName() << " = [";
     const std::vector<Record *> *Elts = Sets.expand(Rec);
     assert(Elts && "Couldn't expand Set instance");
-    for (Record *Elt : *Elts)
+    for (const Record *Elt : *Elts)
       OS << ' ' << Elt->getName();
     OS << " ]\n";
   }
 }
 
-TableGen::Emitter::Opt X[] = {
+static llvm::TableGen::Emitter::Opt X[] = {
     {"print-records", PrintRecords, "Print all records to stdout (default)",
      true},
     {"print-detailed-records", EmitDetailedRecords,
      "Print full details of all records to stdout"},
-    {"null-backend", [](RecordKeeper &Records, raw_ostream &OS) {},
+    {"null-backend", [](const RecordKeeper &Records, raw_ostream &OS) {},
      "Do nothing after parsing (useful for timing)"},
     {"dump-json", EmitJSON, "Dump all records as machine-readable JSON"},
     {"print-enums", PrintEnums, "Print enum values for a class"},
     {"print-sets", PrintSets, "Print expanded sets for testing DAG exprs"},
 };
 
-} // namespace
-
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv);