Define InitLLVM to do common initialization all at once.

[ruiu]

Summary

We have a few functions that virtually all command wants to run on
process startup/shutdown. This patch adds InitLLVM class to do them
all at once, so that we don't copy-n-paste boilerplate code to main()
function of each llvm utility command.

[stella.stamenova]

There are several other tools that have similar initialization (but don't use GetArgumentVector). They should be updated also - and that will also fix their issue with UTF-8 on Windows.

llvm/tools/llvm-rc/llvm-rc.cpp

81

By doing this in this file, ExitOnErr (which is used later in the main function) no longer has the banner set. I suspect the same may be true in some of the other files too.

Perhaps InitLLVM could return an ExitOnError object which is already initialized with the correct banner?

[ruiu]

• set banners to ExitOnError objects

llvm/tools/llvm-rc/llvm-rc.cpp

81

Looks like ExitOnError can take a banner as its constructor argument.

[ruiu]

• convert more tools to use InitLLVM

[stella.stamenova]

llvm/tools/llvm-ar/llvm-ar.cpp

957 ↗

(On Diff #142318)

Why not use ToolName? Or remove ToolName?

llvm/tools/llvm-rc/llvm-rc.cpp

81

I noticed that several of the files that you changed set the banner of ExitOnError after InitLLVM to argv[0] (which is also what InitLLVM does), while a couple set just the name of the tool. Could you change the ones that set just the name of the tool to also use argv[0] for consistency?

[ruiu]

llvm/tools/llvm-ar/llvm-ar.cpp

957 ↗

(On Diff #142318)

No particular reason. Reverted.

llvm/tools/llvm-rc/llvm-rc.cpp

81

I don't want to do that at least in this patch as I want to keep this change as mechanical as possible.

[ruiu]

• address review comment

[ruiu]

• fix unsafe memory access issue

[stella.stamenova]

The last comment would be nice to have, but not necessary. LGTM.

llvm/tools/llvm-rc/llvm-rc.cpp

81

Then in llvm-pdbutil.cpp and here, you should undo the change to the declaration of ExitOnError and bring back the setBanner statements in the main() functions.

lld/tools/lld/lld.cpp

 // to argv[0].
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/Driver.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
-#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/PrettyStackTrace.h"
-#include "llvm/Support/Signals.h"
 #include <cstdlib>
 
 using namespace lld;
 using namespace llvm;
 using namespace llvm::sys;
 
 enum Flavor {
   Invalid,

 // We don't want to do that if we are running tests though, because
 // doing that breaks leak sanitizer. So, lit sets this environment variable,
 // and we use it to detect whether we are running tests or not.
 static bool canExitEarly() { return StringRef(getenv("LLD_IN_TEST")) != "1"; }
 
 /// Universal linker main(). This linker emulates the gnu, darwin, or
 /// windows linker based on the argv[0] or -flavor option.
 int main(int Argc, const char **Argv) {
-  // Standard set up, so program fails gracefully.
-  sys::PrintStackTraceOnErrorSignal(Argv[0]);
-  PrettyStackTraceProgram StackPrinter(Argc, Argv);
-  llvm_shutdown_obj Shutdown;
+  InitLLVM X(Argc, Argv);
 
   std::vector<const char *> Args(Argv, Argv + Argc);
   switch (parseFlavor(Args)) {
   case Gnu:
     if (isPETarget(Args))
       return !mingw::link(Args);
     return !elf::link(Args, canExitEarly());
   case WinLink:

llvm/include/llvm/Support/InitLLVM.h

+//===- InitLLVM.h -----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_LLVM_H
+#define LLVM_SUPPORT_LLVM_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/PrettyStackTrace.h"
+
+namespace llvm {
+class InitLLVM {
+public:
+  InitLLVM(int &Argc, const char **&Argv);
+  ~InitLLVM();
+
+private:
+  SmallVector<char *, 0> Buf;
+  SmallVector<const char *, 0> Args;
+  std::string Banner;
+  PrettyStackTraceProgram StackPrinter;
+};
+}
+
+#endif

llvm/lib/Support/CMakeLists.txt

add_llvm_library(LLVMSupport
   FileUtilities.cpp
   FileOutputBuffer.cpp
   FoldingSet.cpp
   FormattedStream.cpp
   FormatVariadic.cpp
   GlobPattern.cpp
   GraphWriter.cpp
   Hashing.cpp
+  InitLLVM.cpp
   IntEqClasses.cpp
   IntervalMap.cpp
   JamCRC.cpp
   KnownBits.cpp
   LEB128.cpp
   LineIterator.cpp
   Locale.cpp
   LockFileManager.cpp

llvm/lib/Support/InitLLVM.cpp

+//===-- InitLLVM.cpp -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/PrettyStackTrace.h"
+#include "llvm/Support/Signals.h"
+#include "llvm/Support/StringSaver.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Process.h"
+
+using namespace llvm;
+
+#ifdef _WIN32
+
+static ExitOnError ExitOnErr;
+
+InitLLVM::InitLLVM(int &Argc, const char **&Argv)
+    : StackPrinter(Argc, Argv) {
+  sys::PrintStackTraceOnErrorSignal(Argv[0]);
+
+  Banner = (StringRef(Argv[0]) + ": ").str();
+  ExitOnErr.setBanner(Banner);
+
+  SpecificBumpPtrAllocator<char> Alloc;
+  ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
+      Args, makeArrayRef(Argv, Argc), Alloc)));
+
+  Argc = Args.size();
+  Argv = Args.data();
+}
+
+#else
+
+InitLLVM::InitLLVM(int &Argc, const char **&Argv)
+    : StackPrinter(Argc, Argv) {
+  sys::PrintStackTraceOnErrorSignal(Argv[0]);
+}
+
+#endif
+
+InitLLVM::~InitLLVM() { llvm_shutdown(); }

llvm/tools/llvm-cvtres/llvm-cvtres.cpp

 //===- llvm-cvtres.cpp - Serialize .res files into .obj ---------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Serialize .res files into .obj files.  This is intended to be a
 // platform-independent port of Microsoft's cvtres.exe.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Object/Binary.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/BinaryStreamError.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"

 #include "Opts.inc"
 #undef OPTION
 };
 
 class CvtResOptTable : public opt::OptTable {
 public:
   CvtResOptTable() : OptTable(InfoTable, true) {}
 };
-
-static ExitOnError ExitOnErr;
 }
 
 LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
   errs() << Msg;
   exit(1);
 }
 
 static void reportError(StringRef Input, std::error_code EC) {

 }
 
 template <typename T> T error(Expected<T> EC) {
   if (!EC)
     error(EC.takeError());
   return std::move(EC.get());
 }
 
-int main(int argc_, const char *argv_[]) {
-  sys::PrintStackTraceOnErrorSignal(argv_[0]);
-  PrettyStackTraceProgram X(argc_, argv_);
-
-  ExitOnErr.setBanner("llvm-cvtres: ");
-
-  SmallVector<const char *, 256> argv;
-  SpecificBumpPtrAllocator<char> ArgAllocator;
-  ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
-      argv, makeArrayRef(argv_, argc_), ArgAllocator)));
-
-  llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
+int main(int Argc, const char **Argv) {
+  InitLLVM X(Argc, Argv);
 
   CvtResOptTable T;
   unsigned MAI, MAC;
-  ArrayRef<const char *> ArgsArr = makeArrayRef(argv_ + 1, argc_);
+  ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc);
   opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
 
   if (InputArgs.hasArg(OPT_HELP)) {
     T.PrintHelp(outs(), "cvtres", "Resource Converter", false);
     return 0;
   }
 
   bool Verbose = InputArgs.hasArg(OPT_VERBOSE);

llvm/tools/llvm-mt/llvm-mt.cpp

 //===- llvm-mt.cpp - Merge .manifest files ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 //
 // Merge .manifest files.  This is intended to be a platform-independent port
 // of Microsoft's mt.exe.
 //
 //===---------------------------------------------------------------------===//
 
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"

 #include "Opts.inc"
 #undef OPTION
 };
 
 class CvtResOptTable : public opt::OptTable {
 public:
   CvtResOptTable() : OptTable(InfoTable, true) {}
 };
-
-static ExitOnError ExitOnErr;
 } // namespace
 
 LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
   errs() << "llvm-mt error: " << Msg << "\n";
   exit(1);
 }
 
 static void reportError(StringRef Input, std::error_code EC) {
   reportError(Twine(Input) + ": " + EC.message());
 }
 
 void error(std::error_code EC) {
   if (EC)
     reportError(EC.message());
 }
 
 void error(Error EC) {
   if (EC)
     handleAllErrors(std::move(EC), [&](const ErrorInfoBase &EI) {
       reportError(EI.message());
     });
 }
 
-int main(int argc, const char **argv) {
-  sys::PrintStackTraceOnErrorSignal(argv[0]);
-  PrettyStackTraceProgram X(argc, argv);
-
-  ExitOnErr.setBanner("llvm-mt: ");
-
-  SmallVector<const char *, 256> argv_buf;
-  SpecificBumpPtrAllocator<char> ArgAllocator;
-  ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
-      argv_buf, makeArrayRef(argv, argc), ArgAllocator)));
-  llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
+int main(int Argc, const char **Argv) {
+  InitLLVM X(Argc, Argv);
 
   CvtResOptTable T;
   unsigned MAI, MAC;
-  ArrayRef<const char *> ArgsArr = makeArrayRef(argv + 1, argc);
+  ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc);
   opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
 
   for (auto *Arg : InputArgs.filtered(OPT_INPUT)) {
     auto ArgString = Arg->getAsString(InputArgs);
     std::string Diag;
     raw_string_ostream OS(Diag);
     OS << "invalid option '" << ArgString << "'";
 

llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp

 #include "PrettyFunctionDumper.h"
 #include "PrettyTypeDumper.h"
 #include "PrettyVariableDumper.h"
 #include "YAMLOutputStyle.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"

 cl::opt<bool> ForceName("name",
                         cl::desc("Force the interpretation of -stream as a "
                                  "string, even if it is a valid integer"),
                         cl::sub(ExportSubcommand), cl::Optional,
                         cl::init(false));
 } // namespace exportstream
 }
 
-static ExitOnError ExitOnErr;
+static ExitOnError ExitOnErr("llvm-pdbutil: ");
 
 static void yamlToPdb(StringRef Path) {
   BumpPtrAllocator Allocator;
   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
       MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
                                    /*RequiresNullTerminator=*/false);
 
   if (ErrorOrBuffer.getError()) {
static void simplifyChunkList(llvm::cl::list<opts::ModuleSubsection> &Chunks) {
   // If this list contains "All" plus some other stuff, remove the other stuff
   // and just keep "All" in the list.
   if (!llvm::is_contained(Chunks, opts::ModuleSubsection::All))
     return;
   Chunks.reset();
   Chunks.push_back(opts::ModuleSubsection::All);
 }
 
-int main(int argc_, const char *argv_[]) {
-  // Print a stack trace if we signal out.
-  sys::PrintStackTraceOnErrorSignal(argv_[0]);
-  PrettyStackTraceProgram X(argc_, argv_);
+int main(int Argc, const char **Argv) {
+  InitLLVM X(Argc, Argv);
 
-  ExitOnErr.setBanner("llvm-pdbutil: ");
-
-  SmallVector<const char *, 256> argv;
-  SpecificBumpPtrAllocator<char> ArgAllocator;
-  ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
-      argv, makeArrayRef(argv_, argc_), ArgAllocator)));
-
-  llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
-
-  cl::ParseCommandLineOptions(argv.size(), argv.data(), "LLVM PDB Dumper\n");
+  cl::ParseCommandLineOptions(Argc, Argv, "LLVM PDB Dumper\n");
 
   if (opts::BytesSubcommand) {
     if (!parseRange(opts::bytes::DumpBlockRangeOpt,
                     opts::bytes::DumpBlockRange)) {
       errs() << "Argument '" << opts::bytes::DumpBlockRangeOpt
              << "' invalid format.\n";
       errs().flush();
       exit(1);

llvm/tools/llvm-rc/llvm-rc.cpp

 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <system_error>
 
 using namespace llvm;
 using namespace llvm::rc;
 
 namespace {

 #undef OPTION
 };
 
 class RcOptTable : public opt::OptTable {
 public:
   RcOptTable() : OptTable(InfoTable, /* IgnoreCase = */ true) {}
 };
 
-static ExitOnError ExitOnErr;
+static ExitOnError ExitOnErr("llvm-rc: ");
 
 LLVM_ATTRIBUTE_NORETURN static void fatalError(const Twine &Message) {
   errs() << Message << "\n";
   exit(1);
 }
 
 } // anonymous namespace
 
-int main(int argc_, const char *argv_[]) {
-  sys::PrintStackTraceOnErrorSignal(argv_[0]);
-  PrettyStackTraceProgram X(argc_, argv_);
-
-  ExitOnErr.setBanner("llvm-rc: ");
-
-  SmallVector<const char *, 256> argv;
-  SpecificBumpPtrAllocator<char> ArgAllocator;
-  ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
-      argv, makeArrayRef(argv_, argc_), ArgAllocator)));
-
-  llvm_shutdown_obj Y;
+int main(int Argc, const char **Argv) {
+  InitLLVM X(Argc, Argv);
 
   RcOptTable T;
   unsigned MAI, MAC;
-  ArrayRef<const char *> ArgsArr = makeArrayRef(argv_ + 1, argc_);
+  ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc);
   opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
 
   // The tool prints nothing when invoked with no command-line arguments.
   if (InputArgs.hasArg(OPT_HELP)) {
     T.PrintHelp(outs(), "rc", "Resource Converter", false);
     return 0;
   }