TableGen: require tablegen cl::opts to be registered explicitly

[nhaehnle]

Summary

We plan to include the TableGen library into the LLVM shared library.
This is a preparatory change to avoid polluting the command-line options
space of non-tablegen tools.

See: https://discourse.llvm.org/t/rfc-cleaning-up-how-we-link-tablegen-tools/66678

[MaskRay]

This is similar to mlir::register*Options and looks good to me.

clang/utils/TableGen/TableGen.cpp

bool ClangTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
 
   return false;
 }
 }
 
 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
+  registerTableGenOptions();
   cl::ParseCommandLineOptions(argc, argv);
 
   llvm_shutdown_obj Y;
 
   return TableGenMain(argv[0], &ClangTableGenMain);
 }
 
 #ifdef __has_feature
 #if __has_feature(address_sanitizer)
 #include <sanitizer/lsan_interface.h>
 // Disable LeakSanitizer for this binary as it has too many leaks that are not
 // very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h .
 int __lsan_is_turned_off() { return 1; }
 #endif  // __has_feature(address_sanitizer)
 #endif  // defined(__has_feature)

libc/utils/HdrGen/Main.cpp

bool HeaderGeneratorMain(llvm::raw_ostream &OS, llvm::RecordKeeper &Records) {
   G.generate(OS, Records);
 
   return false;
 }
 
 } // namespace llvm_libc
 
 int main(int argc, char *argv[]) {
+  llvm::registerTableGenOptions();
   llvm::cl::ParseCommandLineOptions(argc, argv);
-  return TableGenMain(argv[0], &llvm_libc::HeaderGeneratorMain);
+  return llvm::TableGenMain(argv[0], &llvm_libc::HeaderGeneratorMain);
 }

libc/utils/HdrGen/PrototypeTestGen/PrototypeTestGen.cpp

bool TestGeneratorMain(llvm::raw_ostream &OS, llvm::RecordKeeper &records) {
   // when LLVM libc does to include them.
   OS << "void *malloc(size_t) { return nullptr; }\n";
   OS << "void free(void *) {}\n";
 
   return false;
 }
 
 int main(int argc, char *argv[]) {
+  llvm::registerTableGenOptions();
   llvm::cl::ParseCommandLineOptions(argc, argv);
-  return TableGenMain(argv[0], TestGeneratorMain);
+  return llvm::TableGenMain(argv[0], TestGeneratorMain);
 }

libc/utils/tools/WrapperGen/Main.cpp

if (GenWrapper)
     return generateWrapper(OS, Records);
   if (GenAlias)
     return generateAlias(OS, Records);
 
   __builtin_unreachable();
 }
 
 int main(int argc, char *argv[]) {
+  llvm::registerTableGenOptions();
   llvm::cl::ParseCommandLineOptions(argc, argv);
-  return TableGenMain(argv[0], wrapperGenMain);
+  return llvm::TableGenMain(argv[0], wrapperGenMain);
 }

lldb/utils/TableGen/LLDBTableGen.cpp

case GenPropertyEnumDefs:
     break;
   }
   return false;
 }
 
 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
+  registerTableGenOptions();
   cl::ParseCommandLineOptions(argc, argv);
 
   llvm_shutdown_obj Y;
 
   return TableGenMain(argv[0], &LLDBTableGenMain);
 }
 
 #ifdef __has_feature
 #if __has_feature(address_sanitizer)
 #include <sanitizer/lsan_interface.h>
 // Disable LeakSanitizer for this binary as it has too many leaks that are not
 // very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h .
 int __lsan_is_turned_off() { return 1; }
 #endif // __has_feature(address_sanitizer)
 #endif // defined(__has_feature)

llvm/include/llvm/TableGen/Main.h

 #ifndef LLVM_TABLEGEN_MAIN_H
 #define LLVM_TABLEGEN_MAIN_H
 
 namespace llvm {
 
 class raw_ostream;
 class RecordKeeper;
 
+void registerTableGenOptions();
+
 /// Perform the action using Records, and write output to OS.
 /// Returns true on error, false otherwise.
 using TableGenMainFn = bool (raw_ostream &OS, RecordKeeper &Records);
 
 int TableGenMain(const char *argv0, TableGenMainFn *MainFn);
 
 } // end namespace llvm
 
 #endif // LLVM_TABLEGEN_MAIN_H

llvm/lib/TableGen/Main.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include <algorithm>
 #include <system_error>
 using namespace llvm;
 
-static cl::opt<std::string>
-OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"),
-               cl::init("-"));
-
-static cl::opt<std::string>
-DependFilename("d",
-               cl::desc("Dependency filename"),
+namespace {
+
+struct TableGenOptions {
+  cl::opt<std::string> OutputFilename{"o", cl::desc("Output filename"),
                                       cl::value_desc("filename"),
-               cl::init(""));
+                                      cl::init("-")};
+
+  cl::opt<std::string> DependFilename{"d", cl::desc("Dependency filename"),
+                                      cl::value_desc("filename"), cl::init("")};
 
-static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
+  cl::opt<std::string> InputFilename{cl::Positional, cl::desc("<input file>"),
+                                     cl::init("-")};
 
-static cl::list<std::string>
-IncludeDirs("I", cl::desc("Directory of include files"),
-            cl::value_desc("directory"), cl::Prefix);
+  cl::list<std::string> IncludeDirs{"I", cl::desc("Directory of include files"),
+                                    cl::value_desc("directory"), cl::Prefix};
 
-static cl::list<std::string>
-MacroNames("D", cl::desc("Name of the macro to be defined"),
-            cl::value_desc("macro name"), cl::Prefix);
+  cl::list<std::string> MacroNames{"D",
+                                   cl::desc("Name of the macro to be defined"),
+                                   cl::value_desc("macro name"), cl::Prefix};
 
-static cl::opt<bool>
-WriteIfChanged("write-if-changed", cl::desc("Only write output if it changed"));
+  cl::opt<bool> WriteIfChanged{"write-if-changed",
+                               cl::desc("Only write output if it changed")};
 
-static cl::opt<bool>
-TimePhases("time-phases", cl::desc("Time phases of parser and backend"));
+  cl::opt<bool> TimePhases{"time-phases",
+                           cl::desc("Time phases of parser and backend")};
 
-static cl::opt<bool> NoWarnOnUnusedTemplateArgs(
+  cl::opt<bool> NoWarnOnUnusedTemplateArgs{
       "no-warn-on-unused-template-args",
-    cl::desc("Disable unused template argument warnings."));
+      cl::desc("Disable unused template argument warnings.")};
+};
+
+TableGenOptions &getOpts() {
+  static TableGenOptions Opts;
+  return Opts;
+}
+
+} // anonymous namespace
+
+void llvm::registerTableGenOptions() { (void)getOpts(); }
 
 static int reportError(const char *ProgName, Twine Msg) {
   errs() << ProgName << ": " << Msg;
   errs().flush();
   return 1;
 }
 
 /// Create a dependency file for `-d` option.
 ///
 /// This functionality is really only for the benefit of the build system.
 /// It is similar to GCC's `-M*` family of options.
 static int createDependencyFile(const TGParser &Parser, const char *argv0) {
-  if (OutputFilename == "-")
+  if (getOpts().OutputFilename == "-")
     return reportError(argv0, "the option -d must be used together with -o\n");
 
   std::error_code EC;
-  ToolOutputFile DepOut(DependFilename, EC, sys::fs::OF_Text);
+  ToolOutputFile DepOut(getOpts().DependFilename, EC, sys::fs::OF_Text);
   if (EC)
-    return reportError(argv0, "error opening " + DependFilename + ":" +
-                                  EC.message() + "\n");
-  DepOut.os() << OutputFilename << ":";
+    return reportError(argv0, "error opening " + getOpts().DependFilename +
+                                  ":" + EC.message() + "\n");
+  DepOut.os() << getOpts().OutputFilename << ":";
   for (const auto &Dep : Parser.getDependencies()) {
     DepOut.os() << ' ' << Dep;
   }
   DepOut.os() << "\n";
   DepOut.keep();
   return 0;
 }
 
 int llvm::TableGenMain(const char *argv0, TableGenMainFn *MainFn) {
   RecordKeeper Records;
 
-  if (TimePhases)
+  if (getOpts().TimePhases)
     Records.startPhaseTiming();
 
   // Parse the input file.
 
   Records.startTimer("Parse, build records");
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(InputFilename, /*IsText=*/true);
-  if (std::error_code EC = FileOrErr.getError())
-    return reportError(argv0, "Could not open input file '" + InputFilename +
+      MemoryBuffer::getFileOrSTDIN(getOpts().InputFilename, /*IsText=*/true);
+  if (std::error_code EC = FileOrErr.getError()) {
+    return reportError(argv0, "Could not open input file '" +
+                                  getOpts().InputFilename +
                                   "': " + EC.message() + "\n");
+  }
 
-  Records.saveInputFilename(InputFilename);
+  Records.saveInputFilename(getOpts().InputFilename);
 
   // Tell SrcMgr about this buffer, which is what TGParser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());
 
   // Record the location of the include directory so that the lexer can find
   // it later.
-  SrcMgr.setIncludeDirs(IncludeDirs);
+  SrcMgr.setIncludeDirs(getOpts().IncludeDirs);
 
-  TGParser Parser(SrcMgr, MacroNames, Records, NoWarnOnUnusedTemplateArgs);
+  TGParser Parser(SrcMgr, getOpts().MacroNames, Records,
+                  getOpts().NoWarnOnUnusedTemplateArgs);
 
   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 = MainFn(Out, Records);
   Records.stopBackendTimer();
   if (status)
     return 1;
 
   // Always write the depfile, even if the main output hasn't changed.
   // If it's missing, Ninja considers the output dirty.  If this was below
   // the early exit below and someone deleted the .inc.d file but not the .inc
   // file, tablegen would never write the depfile.
-  if (!DependFilename.empty()) {
+  if (!getOpts().DependFilename.empty()) {
     if (int Ret = createDependencyFile(Parser, argv0))
       return Ret;
   }
 
   Records.startTimer("Write output");
   bool WriteFile = true;
-  if (WriteIfChanged) {
+  if (getOpts().WriteIfChanged) {
     // Only updates the real output file if there are any differences.
     // This prevents recompilation of all the files depending on it if there
     // aren't any.
     if (auto ExistingOrErr =
-            MemoryBuffer::getFile(OutputFilename, /*IsText=*/true))
+            MemoryBuffer::getFile(getOpts().OutputFilename, /*IsText=*/true))
       if (std::move(ExistingOrErr.get())->getBuffer() == Out.str())
         WriteFile = false;
   }
   if (WriteFile) {
     std::error_code EC;
-    ToolOutputFile OutFile(OutputFilename, EC, sys::fs::OF_Text);
+    ToolOutputFile OutFile(getOpts().OutputFilename, EC, sys::fs::OF_Text);
     if (EC)
-      return reportError(argv0, "error opening " + OutputFilename + ": " +
-                                    EC.message() + "\n");
+      return reportError(argv0, "error opening " + getOpts().OutputFilename +
+                                    ": " + EC.message() + "\n");
     OutFile.os() << Out.str();
     if (ErrorsPrinted == 0)
       OutFile.keep();
   }
   
   Records.stopTimer();
   Records.stopPhaseTiming();
 
   if (ErrorsPrinted > 0)
     return reportError(argv0, Twine(ErrorsPrinted) + " errors.\n");
   return 0;
 }

llvm/tools/llvm-shlib/CMakeLists.txt

if(LLVM_BUILD_LLVM_DYLIB)
   if(MSVC)
     message(FATAL_ERROR "Generating libLLVM is not supported on MSVC")
   endif()
 
   llvm_map_components_to_libnames(LIB_NAMES ${LLVM_DYLIB_COMPONENTS})
 
   # Exclude libLLVMTableGen for the following reasons:
   #  - it is only used by internal *-tblgen utilities;
-  #  - it pollutes the global options space.
   list(REMOVE_ITEM LIB_NAMES "LLVMTableGen")
 
   if(LLVM_DYLIB_EXPORTED_SYMBOL_FILE)
     set(LLVM_EXPORTED_SYMBOL_FILE ${LLVM_DYLIB_EXPORTED_SYMBOL_FILE})
     add_custom_target(libLLVMExports DEPENDS ${LLVM_EXPORTED_SYMBOL_FILE})
   endif()
 
   if (LLVM_LINK_LLVM_DYLIB)

llvm/utils/TableGen/TableGen.cpp

bool LLVMTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
   }
 
   return false;
 }
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
+  registerTableGenOptions();
   cl::ParseCommandLineOptions(argc, argv);
 
   return TableGenMain(argv[0], &LLVMTableGenMain);
 }
 
 #ifndef __has_feature
 #define __has_feature(x) 0
 #endif

mlir/lib/Tools/mlir-tblgen/MlirTblgenMain.cpp

llvm::cl::opt<DeprecatedAction, true> actionOnDeprecated(
           clEnumValN(DeprecatedAction::None, "none", "No action"),
           clEnumValN(DeprecatedAction::Warn, "warn", "Warn on use"),
           clEnumValN(DeprecatedAction::Error, "error", "Error on use")),
       cl::location(actionOnDeprecatedValue), llvm::cl::init(Warn));
 
   llvm::cl::opt<const mlir::GenInfo *, true, mlir::GenNameParser> generator(
       "", llvm::cl::desc("Generator to run"), cl::location(::generator));
 
+  llvm::registerTableGenOptions();
   cl::ParseCommandLineOptions(argc, argv);
 
   return TableGenMain(argv[0], &mlirTableGenMain);
 }