llvm-tblgen: Let each emitter self-contained

[chapuni]

Summary

llvm-tblgen: Introduce llvm::TableGen::Emitter to register backends

Opt(flag, func, desc, default) registers an option into Action.

OptClass<EmitterC> is also available if EmitterC(RK).run(OS) is capable.

Action is defined as ManagedStatic<cl::opt> to guarantee to be created
when each registration of emitter is invoked.

FIXME: This may be move to llvm/include/llvm/TableGen/Main.h

llvm-tblgen: Cleanup for each EmitterClass to be invoked by uniform signature.

llvm-tblgen: Rewrite emitters to use TableGen::Emitter

Each emitter became self-contained since it has the registration of option.

[craig.topper]

llvm/utils/TableGen/AsmMatcherEmitter.cpp

4007 ↗

(On Diff #498675)

I believe LLVM coding standards say to prefer static over anonymous namespaces. https://llvm.org/docs/CodingStandards.html#anonymous-namespaces. "make anonymous namespaces as small as possible, and only use them for class declarations."

[chapuni]

llvm/utils/TableGen/AsmMatcherEmitter.cpp

4007 ↗

(On Diff #498675)

I have misunderstood usage of anonymous namespace. I will rework later.

I committed also c45e90cf152decb1a3dcd208273ca025e14f1b4f as a trivial change but I have noticed I did wrong thing. I will rework as well.

[chapuni]

• Avoid easy use of anonymous namespace
• Move decl of EmitDecoder()to TableGenBackends.h
• llvm::TableGen::Emitter::Opt(): Add 4th arg, isDefault
• LLVMTableGenMain() assumes TableGen::Emitter::Action is not null.

[myhsu]

In D144351#4138905, @chapuni wrote:

• Move decl of EmitDecoder()to TableGenBackends.h

maybe a dumb question: why?

llvm/utils/TableGen/TableGenBackends.h

80 ↗

(On Diff #498828)

nit: I believe function argument names should be camel case starting with upper case letter.

[chapuni]

• Fixup namings

[chapuni]

In D144351#4139448, @myhsu wrote:

In D144351#4138905, @chapuni wrote:

• Move decl of EmitDecoder()to TableGenBackends.h

maybe a dumb question: why?

DisassemblerEmitter.cpp declares it as ad-hoc decl extern. Since I touched around it, I have moved it to other header.
I have taken TableGenBackends.h since I thought excessive to introduce a new header like DecoderEmitter.h.

llvm/utils/TableGen/TableGenBackends.h

80 ↗

(On Diff #498828)

I have followed CommandLine.h.

[myhsu]

I think this patch generally LGTM. But I would love to know if plugin support or third-party extension in general is part of your roadmap, if that's the case...

FIXME: This may be move to llvm/include/llvm/TableGen/Main.h

then yeah, moving it to public header might be a good idea.

[chapuni]

In D144351#4148987, @myhsu wrote:

then yeah, moving it to public header might be a good idea.

I'm afraid if it would affect other *-tblgen. It was in public in my prototype.
I'd be happy to move it to public step-by-step.

When we could implement tblgen plugin, I wonder;

• If we took -load foo-pluigin.so, how it could be activated. I guess we should enhance TableGen::Emitter::Opt to activate myself. In my current implementation, TableGen::Emitter::Opt just registers an option.
• Or, could we enforce users to name their plugin as libtblgen-foo-option.so?

[chapuni]

• Move llvm::TableGen::Emitter to llvm/TableGen/TableGenBackend.h
• TableGen/BackGuide.rst: Modify using llvm::TableGen::Emitter`

[chapuni]

@myhsu I have exposed llvm::TableGen::Emitter into llvm/TableGen/TableGenBackend.h.

[myhsu]

LGTM Cheers

In D144351#4152342, @chapuni wrote:

In D144351#4148987, @myhsu wrote:

then yeah, moving it to public header might be a good idea.

I'm afraid if it would affect other *-tblgen. It was in public in my prototype.
I'd be happy to move it to public step-by-step.

When we could implement tblgen plugin, I wonder;

• If we took -load foo-pluigin.so, how it could be activated. I guess we should enhance TableGen::Emitter::Opt to activate myself. In my current implementation, TableGen::Emitter::Opt just registers an option.

IMHO activation upon the plugin is loaded makes more sense, because unlike using opt with legacy PassManager, there won't be multiple TG actions in a single invocation.

llvm/docs/TableGen/BackGuide.rst

 
 #. Write the new backend, using the file ``TableGenBackendSkeleton.cpp``
    as a starting point.
 
 #. Determine which instance of TableGen requires the new backend. There is
    one instance for Clang and another for LLVM. Or you may be building
    your own instance.
 
-#. Modify the selected ``tablegen.cpp`` to include your new backend.
-
-  a. Add the name to the enumerated type ``ActionType``.
-
-  #. Add a keyword to the ``ActionType`` command option using the
-     ``clEnumValN()`` function.
-
-  #. Add a case to the ``switch`` statement in the *xxx*\ ``TableGenMain()``
-     function. It should invoke the "main function" of your backend, which
-     in this case, according to convention, is named ``EmitAddressModes``.
-
-5. Add a declaration of your "main function" to the corresponding
-   ``TableGenBackends.h`` header file.
-
 #. Add your backend C++ file to the appropriate ``CMakeLists.txt`` file so
    that it will be built.
 
 #. Add your C++ file to the system.
 
 The Backend Skeleton
 ====================
 

 * One function is named ``run``. It is invoked by the backend's "main
   function" to collect records and emit the output file. It accepts an instance
   of the ``raw_ostream`` class, typically named ``OS``. The output file is
   emitted by writing to this stream.
 
 * The ``run`` function should use the ``emitSourceFileHeader`` helper function
   to include a standard header in the emitted file.
 
-* The only function in the ``llvm`` namespace is the backend "main function."
-  In this example, it is named ``EmitAddressModes``. It creates an instance
-  of the ``AddressModesEmitter`` class, passing the ``RecordKeeper``
-  instance, then invokes the ``run`` function, passing the ``raw_ostream``
-  instance.
+* Register the class or the function as the command line option
+  with ``llvm/TableGen/TableGenBackend.h``.
+
+  * Use ``llvm::TableGen::Emitter::OptClass<AddressModesEmitter>``
+    if the class has the constructor ``(RK)`` and
+    the method ``run(OS)``.
+
+  * Otherwise, use ``llvm::TableGen::Emitter::Opt``.
 
 All the examples in the remainder of this document will assume the naming
 conventions used in the skeleton file.
 
 Getting Classes
 ===============
 
 The ``RecordKeeper`` class provides two functions for getting the

llvm/include/llvm/TableGen/TableGenBackend.h

 //===- llvm/TableGen/TableGenBackend.h - Backend utilities ------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Useful utilities for TableGen backends.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TABLEGEN_TABLEGENBACKEND_H
 #define LLVM_TABLEGEN_TABLEGENBACKEND_H
 
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ManagedStatic.h"
+
 namespace llvm {
 
-class StringRef;
+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;
+
+struct Opt {
+  Opt(StringRef Name, FnT CB, StringRef Desc, bool ByDefault = false) {
+    if (ByDefault)
+      Action->setInitialValue(CB);
+    Action->getParser().addLiteralOption(Name, CB, Desc);
+  }
+};
+
+template <class EmitterC> class OptClass : Opt {
+  static void run(RecordKeeper &RK, raw_ostream &OS) { EmitterC(RK).run(OS); }
+
+public:
+  OptClass(StringRef Name, StringRef Desc) : Opt(Name, run, Desc) {}
+};
+
+} // namespace TableGen::Emitter
+
 /// emitSourceFileHeader - Output an LLVM style file header to the specified
 /// raw_ostream.
 void emitSourceFileHeader(StringRef Desc, raw_ostream &OS);
 
 extern bool TimeRegions;
 
 } // End llvm namespace
 
 #endif

llvm/lib/TableGen/Main.cpp

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/TableGenBackend.h"
 #include <memory>
 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 using namespace llvm;
 
 static cl::opt<std::string>
if (Parser.ParseFile())
     return 1;
   Records.stopTimer();
 
   // Write output to memory.
   Records.startBackendTimer("Backend overall");
   std::string OutString;
   raw_string_ostream Out(OutString);
   unsigned status = 0;
-  if (MainFn)
+  TableGen::Emitter::FnT ActionFn = TableGen::Emitter::Action->getValue();
+  if (ActionFn)
+    ActionFn(Records, Out);
+  else if (MainFn)
     status = MainFn(Out, Records);
   else
     return 1;
   Records.stopBackendTimer();
   if (status)
     return 1;
 
   // Always write the depfile, even if the main output hasn't changed.

llvm/lib/TableGen/TableGenBackend.cpp

 //===- TableGenBackend.cpp - Utilities for TableGen Backends ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides useful services for TableGen backends...
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/TableGen/TableGenBackend.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
 #include <cassert>
+#include <cstddef>
 
 using namespace llvm;
 
 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 llvm::TableGen::Emitter
+
 static void printLine(raw_ostream &OS, const Twine &Prefix, char Fill,
                       StringRef Suffix) {
   size_t Pos = (size_t)OS.tell();
   assert((Prefix.str().size() + Suffix.size() <= MAX_LINE_LEN) &&
          "header line exceeds max limit");
   OS << Prefix;
   for (size_t i = (size_t)OS.tell() - Pos, e = MAX_LINE_LEN - Suffix.size();
          i < e; ++i)

llvm/lib/TableGen/TableGenBackendSkeleton.cpp

 } // anonymous namespace
 
 void SkeletonEmitter::run(raw_ostream &OS) {
   emitSourceFileHeader("Skeleton data structures", OS);
 
   (void)Records; // To suppress unused variable warning; remove on use.
 }
 
-namespace llvm {
+// Choose either option A or B.
 
-// The only thing that should be in the llvm namespace is the
-// emitter entry point function.
+//===----------------------------------------------------------------------===//
+// Option A: Register the backed as class <SkeletonEmitter>
+static TableGen::Emitter::OptClass<SkeletonEmitter>
+    X("gen-skeleton-class", "Generate example skeleton class");
 
-void EmitSkeleton(RecordKeeper &RK, raw_ostream &OS) {
+//===----------------------------------------------------------------------===//
+// Option B: Register "EmitSkeleton" directly
+// The emitter entry may be private scope.
+static void EmitSkeleton(RecordKeeper &RK, raw_ostream &OS) {
   // Instantiate the emitter class and invoke run().
   SkeletonEmitter(RK).run(OS);
 }
 
-} // namespace llvm
+static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton,
+                                "Generate example skeleton entry");