CommandLine: Cleanup options and remove use of ManagedStatic

[nhaehnle]

Summary

Replace uses of ManagedStatics by function-local static variables.

Also fix a corruption issue when LLVM is used as a shared library in a
plugin setting.

Consider the case where A depends on B depends on LLVM, where B is a
shared compiler library built on LLVM that defines command-line options
because it can also be used in a non-plugin setting.

If A is loaded and unloaded multiple times, causing B to be loaded and
unloaded multiple times while LLVM *isn't* unloaded, then corruption
results without this change: as B is unloaded, its cl::opt globals
disappear but the GlobalParser still holds a (dangling) reference to
them. Furthermore, if A and B are loaded a second time, the cl::opt
globals are constructed again which fails because options of the
same name are still registered.

The straightforward fix is to remove options from the GlobalParser
in the cl::Option destructor (which was previously defaulted but
already non-trivial).

[nhaehnle]

Rebase

[efriedma]

llvm/include/llvm/Support/CommandLine.h

351–352

"This option must have been the last option registered. For testing purposes only."

Is this still accurate? Is it an issue here?

[nhaehnle]

Remove an outdated comment

llvm/include/llvm/Support/CommandLine.h

351–352

Thanks for spotting that. I did look into that when I wrote the code and the comment looks outdated to me. I've also been using these patches for a while now and this doesn't appear to be an issue in practice. I'm going to remove the comment.

[efriedma]

LGTM

llvm/include/llvm/Support/CommandLine.h

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <climits>
 #include <cstddef>
 #include <functional>
 #include <initializer_list>
 #include <string>
 #include <type_traits>
public:
 
   SmallVector<Option *, 4> PositionalOpts;
   SmallVector<Option *, 4> SinkOpts;
   StringMap<Option *> OptionsMap;
 
   Option *ConsumeAfterOpt = nullptr; // The ConsumeAfter option if it exists.
 };
 
-// A special subcommand representing no subcommand
-extern ManagedStatic<SubCommand> TopLevelSubCommand;
-
-// A special subcommand that can be used to put an option into all subcommands.
-extern ManagedStatic<SubCommand> AllSubCommands;
-
 //===----------------------------------------------------------------------===//
 //
 class Option {
   friend class alias;
 
   // Overriden by subclasses to handle the value passed into an argument. Should
   // return true if there was an error processing the argument and the program
   // should exit.
explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
         HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0),
         FullyInitialized(false), Position(0), AdditionalVals(0) {
     Categories.push_back(&getGeneralCategory());
   }
 
   inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
 
 public:
-  virtual ~Option() = default;
+  virtual ~Option() {
+    if (FullyInitialized)
+      removeArgument();
+  }
 
   // Register this argument with the commandline system.
   //
   void addArgument();
 
   /// Unregisters this option from the CommandLine system.
-  ///
-  /// This option must have been the last option registered.
-  /// For testing purposes only.
   void removeArgument();
 
   // Return the width of the option tag for printing...
   virtual size_t getOptionWidth() const = 0;
 
   // Print out information about this option. The to-be-maintained width is
   // specified.
   //
   virtual void printOptionInfo(size_t GlobalWidth) const = 0;

llvm/lib/Support/CommandLine.cpp

 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <string>
if (Opt && LongOptionsUseDoubleDash && !HaveDoubleDash && !isGrouping(Opt))
       return nullptr;
     return Opt;
   }
   SubCommand *LookupSubCommand(StringRef Name);
 };
 
 } // namespace
 
-static ManagedStatic<CommandLineParser> GlobalParser;
+static CommandLineParser &getGlobalParser() {
+  static CommandLineParser GlobalParser;
+  return GlobalParser;
+}
 
 void cl::AddLiteralOption(Option &O, StringRef Name) {
-  GlobalParser->addLiteralOption(O, Name);
+  getGlobalParser().addLiteralOption(O, Name);
 }
 
 extrahelp::extrahelp(StringRef Help) : morehelp(Help) {
-  GlobalParser->MoreHelp.push_back(Help);
+  getGlobalParser().MoreHelp.push_back(Help);
 }
 
 void Option::addArgument() {
-  GlobalParser->addOption(this);
+  getGlobalParser().addOption(this);
   FullyInitialized = true;
 }
 
-void Option::removeArgument() { GlobalParser->removeOption(this); }
+void Option::removeArgument() { getGlobalParser().removeOption(this); }
 
 void Option::setArgStr(StringRef S) {
   if (FullyInitialized)
-    GlobalParser->updateArgStr(this, S);
+    getGlobalParser().updateArgStr(this, S);
   assert((S.empty() || S[0] != '-') && "Option can't start with '-");
   ArgStr = S;
   if (ArgStr.size() == 1)
     setMiscFlag(Grouping);
 }
 
 void Option::addCategory(OptionCategory &C) {
   assert(!Categories.empty() && "Categories cannot be empty.");

 void Option::reset() {
   NumOccurrences = 0;
   setDefault();
   if (isDefaultOption())
     removeArgument();
 }
 
 void OptionCategory::registerCategory() {
-  GlobalParser->registerCategory(this);
+  getGlobalParser().registerCategory(this);
 }
 
-// A special subcommand representing no subcommand. It is particularly important
-// that this ManagedStatic uses constant initailization and not dynamic
-// initialization because it is referenced from cl::opt constructors, which run
-// dynamically in an arbitrary order.
-LLVM_REQUIRE_CONSTANT_INITIALIZATION
-ManagedStatic<SubCommand> llvm::cl::TopLevelSubCommand;
-
-// A special subcommand that can be used to put an option into all subcommands.
-ManagedStatic<SubCommand> llvm::cl::AllSubCommands;
-
-SubCommand &SubCommand::getTopLevel() { return *TopLevelSubCommand; }
+SubCommand &SubCommand::getTopLevel() {
+  static SubCommand TopLevelSubCommand;
+  return TopLevelSubCommand;
+}
 
-SubCommand &SubCommand::getAll() { return *AllSubCommands; }
+SubCommand &SubCommand::getAll() {
+  static SubCommand AllSubCommands;
+  return AllSubCommands;
+}
 
 void SubCommand::registerSubCommand() {
-  GlobalParser->registerSubCommand(this);
+  getGlobalParser().registerSubCommand(this);
 }
 
 void SubCommand::unregisterSubCommand() {
-  GlobalParser->unregisterSubCommand(this);
+  getGlobalParser().unregisterSubCommand(this);
 }
 
 void SubCommand::reset() {
   PositionalOpts.clear();
   SinkOpts.clear();
   OptionsMap.clear();
 
   ConsumeAfterOpt = nullptr;
 }
 
 SubCommand::operator bool() const {
-  return (GlobalParser->getActiveSubCommand() == this);
+  return (getGlobalParser().getActiveSubCommand() == this);
 }
 
 //===----------------------------------------------------------------------===//
 // Basic, shared command line option processing machinery.
 //
 
 /// LookupOption - Lookup the option specified by the specified option on the
 /// command line.  If there is a value specified (after an equal sign) return
bool cl::ParseCommandLineOptions(int argc, const char *const *argv,
   }
 
   // Append options from command line.
   for (int I = 1; I < argc; ++I)
     NewArgv.push_back(argv[I]);
   int NewArgc = static_cast<int>(NewArgv.size());
 
   // Parse all options.
-  return GlobalParser->ParseCommandLineOptions(NewArgc, &NewArgv[0], Overview,
-                                               Errs, LongOptionsUseDoubleDash);
+  return getGlobalParser().ParseCommandLineOptions(
+      NewArgc, &NewArgv[0], Overview, Errs, LongOptionsUseDoubleDash);
 }
 
 /// Reset all options at least once, so that we can parse different options.
 void CommandLineParser::ResetAllOptionOccurrences() {
   // Reset all option values to look like they have never been seen before.
   // Options might be reset twice (they can be reference in both OptionsMap
   // and one of the other members), but that does not harm.
   for (auto *SC : RegisteredSubCommands) {
bool CommandLineParser::ParseCommandLineOptions(int argc,
   SubCommand *ChosenSubCommand = &SubCommand::getTopLevel();
   if (argc >= 2 && argv[FirstArg][0] != '-') {
     // If the first argument specifies a valid subcommand, start processing
     // options from the second argument.
     ChosenSubCommand = LookupSubCommand(StringRef(argv[FirstArg]));
     if (ChosenSubCommand != &SubCommand::getTopLevel())
       FirstArg = 2;
   }
-  GlobalParser->ActiveSubCommand = ChosenSubCommand;
+  getGlobalParser().ActiveSubCommand = ChosenSubCommand;
 
   assert(ChosenSubCommand);
   auto &ConsumeAfterOpt = ChosenSubCommand->ConsumeAfterOpt;
   auto &PositionalOpts = ChosenSubCommand->PositionalOpts;
   auto &SinkOpts = ChosenSubCommand->SinkOpts;
   auto &OptionsMap = ChosenSubCommand->OptionsMap;
 
   for (auto *O: DefaultOptions) {

 //
 
 bool Option::error(const Twine &Message, StringRef ArgName, raw_ostream &Errs) {
   if (!ArgName.data())
     ArgName = ArgStr;
   if (ArgName.empty())
     Errs << HelpStr; // Be nice for positional arguments
   else
-    Errs << GlobalParser->ProgramName << ": for the " << PrintArg(ArgName, 0);
+    Errs << getGlobalParser().ProgramName << ": for the "
+         << PrintArg(ArgName, 0);
 
   Errs << " option: " << Message << "\n";
   return true;
 }
 
 bool Option::addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
                            bool MultiArg) {
   if (!MultiArg)
if (!Value)
       return;
     printHelp();
 
     // Halt the program since help information was printed
     exit(0);
   }
 
   void printHelp() {
-    SubCommand *Sub = GlobalParser->getActiveSubCommand();
+    SubCommand *Sub = getGlobalParser().getActiveSubCommand();
     auto &OptionsMap = Sub->OptionsMap;
     auto &PositionalOpts = Sub->PositionalOpts;
     auto &ConsumeAfterOpt = Sub->ConsumeAfterOpt;
 
     StrOptionPairVector Opts;
     sortOpts(OptionsMap, Opts, ShowHidden);
 
     StrSubCommandPairVector Subs;
-    sortSubCommands(GlobalParser->RegisteredSubCommands, Subs);
+    sortSubCommands(getGlobalParser().RegisteredSubCommands, Subs);
 
-    if (!GlobalParser->ProgramOverview.empty())
-      outs() << "OVERVIEW: " << GlobalParser->ProgramOverview << "\n";
+    if (!getGlobalParser().ProgramOverview.empty())
+      outs() << "OVERVIEW: " << getGlobalParser().ProgramOverview << "\n";
 
-      outs() << "USAGE: " << GlobalParser->ProgramName;
-      if (Sub == &SubCommand::getTopLevel()) {
-        if (Subs.size() > 2)
-          outs() << " [subcommand]";
-        outs() << " [options]";
-      } else {
-        if (!Sub->getDescription().empty()) {
-          outs() << "SUBCOMMAND '" << Sub->getName()
-                 << "': " << Sub->getDescription() << "\n\n";
-        }
-        outs() << "USAGE: " << GlobalParser->ProgramName << " "
-               << Sub->getName() << " [options]";
-      }
+      outs() << "USAGE: " << getGlobalParser().ProgramName;
+      outs() << "USAGE: " << getGlobalParser().ProgramName << " "
 
     for (auto *Opt : PositionalOpts) {
       if (Opt->hasArgStr())
         outs() << " --" << Opt->ArgStr;
       outs() << " " << Opt->HelpStr;
     }
 
     // Print the consume after option info if it exists...
     if (ConsumeAfterOpt)
       outs() << " " << ConsumeAfterOpt->HelpStr;
 
     if (Sub == &SubCommand::getTopLevel() && !Subs.empty()) {
       // Compute the maximum subcommand length...
       size_t MaxSubLen = 0;
       for (size_t i = 0, e = Subs.size(); i != e; ++i)
         MaxSubLen = std::max(MaxSubLen, strlen(Subs[i].first));
 
       outs() << "\n\n";
       outs() << "SUBCOMMANDS:\n\n";
       printSubCommands(Subs, MaxSubLen);
       outs() << "\n";
-      outs() << "  Type \"" << GlobalParser->ProgramName
+      outs() << "  Type \"" << getGlobalParser().ProgramName
              << " <subcommand> --help\" to get more help on a specific "
                 "subcommand";
     }
 
     outs() << "\n\n";
 
     // Compute the maximum argument length...
     size_t MaxArgLen = 0;
     for (size_t i = 0, e = Opts.size(); i != e; ++i)
       MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
 
     outs() << "OPTIONS:\n";
     printOptions(Opts, MaxArgLen);
 
     // Print any extra help the user has declared.
-    for (const auto &I : GlobalParser->MoreHelp)
+    for (const auto &I : getGlobalParser().MoreHelp)
       outs() << I;
-    GlobalParser->MoreHelp.clear();
+    getGlobalParser().MoreHelp.clear();
   }
 };
 
 class CategorizedHelpPrinter : public HelpPrinter {
 public:
   explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {}
 
   // Helper function for printOptions().

 
 protected:
   void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) override {
     std::vector<OptionCategory *> SortedCategories;
     DenseMap<OptionCategory *, std::vector<Option *>> CategorizedOptions;
 
     // Collect registered option categories into vector in preparation for
     // sorting.
-    for (OptionCategory *Category : GlobalParser->RegisteredOptionCategories)
+    for (OptionCategory *Category :
+         getGlobalParser().RegisteredOptionCategories)
       SortedCategories.push_back(Category);
 
     // Sort the different option categories alphabetically.
     assert(SortedCategories.size() > 0 && "No option categories registered!");
     array_pod_sort(SortedCategories.begin(), SortedCategories.end(),
                    OptionCategoryCompare);
 
     // Walk through pre-sorted options and assign into categories.
struct CommandLineCommonOptions {
   // Define the --version option that prints out the LLVM version for the tool
   VersionPrinter VersionPrinterInstance;
 
   cl::opt<VersionPrinter, true, parser<bool>> VersOp{
       "version", cl::desc("Display the version of this program"),
       cl::location(VersionPrinterInstance), cl::ValueDisallowed,
       cl::cat(GenericCategory)};
 };
-} // End anonymous namespace
 
-// Lazy-initialized global instance of options controlling the command-line
-// parser and general handling.
-static ManagedStatic<CommandLineCommonOptions> CommonOptions;
+static CommandLineCommonOptions &getCommonOptions() {
+  static CommandLineCommonOptions CommonOptions;
+  return CommonOptions;
+}
+
+} // End anonymous namespace
 
 static void initCommonOptions() {
-  *CommonOptions;
+  getCommonOptions();
   initDebugCounterOptions();
   initGraphWriterOptions();
   initSignalsOptions();
   initStatisticOptions();
   initTimerOptions();
   initTypeSizeOptions();
   initWithColorOptions();
   initDebugOptions();
   initRandomSeedOptions();
 }
 
 OptionCategory &cl::getGeneralCategory() {
   // Initialise the general option category.
   static OptionCategory GeneralCategory{"General options"};
   return GeneralCategory;
 }
 
 void VersionPrinter::operator=(bool OptionWasSpecified) {
   if (!OptionWasSpecified)
     return;
 
-  if (CommonOptions->OverrideVersionPrinter != nullptr) {
-    CommonOptions->OverrideVersionPrinter(outs());
+  if (getCommonOptions().OverrideVersionPrinter != nullptr) {
+    getCommonOptions().OverrideVersionPrinter(outs());
     exit(0);
   }
   print();
 
   // Iterate over any registered extra printers and call them to add further
   // information.
-  if (!CommonOptions->ExtraVersionPrinters.empty()) {
+  if (!getCommonOptions().ExtraVersionPrinters.empty()) {
     outs() << '\n';
-    for (const auto &I : CommonOptions->ExtraVersionPrinters)
+    for (const auto &I : getCommonOptions().ExtraVersionPrinters)
       I(outs());
   }
 
   exit(0);
 }
 
 void HelpPrinterWrapper::operator=(bool Value) {
   if (!Value)
     return;
 
   // Decide which printer to invoke. If more than one option category is
   // registered then it is useful to show the categorized help instead of
   // uncategorized help.
-  if (GlobalParser->RegisteredOptionCategories.size() > 1) {
+  if (getGlobalParser().RegisteredOptionCategories.size() > 1) {
     // unhide --help-list option so user can have uncategorized output if they
     // want it.
-    CommonOptions->HLOp.setHiddenFlag(NotHidden);
+    getCommonOptions().HLOp.setHiddenFlag(NotHidden);
 
     CategorizedPrinter = true; // Invoke categorized printer
   } else
     UncategorizedPrinter = true; // Invoke uncategorized printer
 }
 
 // Print the value of each option.
-void cl::PrintOptionValues() { GlobalParser->printOptionValues(); }
+void cl::PrintOptionValues() { getGlobalParser().printOptionValues(); }
 
 void CommandLineParser::printOptionValues() {
-  if (!CommonOptions->PrintOptions && !CommonOptions->PrintAllOptions)
+  if (!getCommonOptions().PrintOptions && !getCommonOptions().PrintAllOptions)
     return;
 
   SmallVector<std::pair<const char *, Option *>, 128> Opts;
   sortOpts(ActiveSubCommand->OptionsMap, Opts, /*ShowHidden*/ true);
 
   // Compute the maximum argument length...
   size_t MaxArgLen = 0;
   for (size_t i = 0, e = Opts.size(); i != e; ++i)
     MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
 
   for (size_t i = 0, e = Opts.size(); i != e; ++i)
-    Opts[i].second->printOptionValue(MaxArgLen, CommonOptions->PrintAllOptions);
+    Opts[i].second->printOptionValue(MaxArgLen,
+                                     getCommonOptions().PrintAllOptions);
 }
 
 // Utility function for printing the help message.
 void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
   if (!Hidden && !Categorized)
-    CommonOptions->UncategorizedNormalPrinter.printHelp();
+    getCommonOptions().UncategorizedNormalPrinter.printHelp();
   else if (!Hidden && Categorized)
-    CommonOptions->CategorizedNormalPrinter.printHelp();
+    getCommonOptions().CategorizedNormalPrinter.printHelp();
   else if (Hidden && !Categorized)
-    CommonOptions->UncategorizedHiddenPrinter.printHelp();
+    getCommonOptions().UncategorizedHiddenPrinter.printHelp();
   else
-    CommonOptions->CategorizedHiddenPrinter.printHelp();
+    getCommonOptions().CategorizedHiddenPrinter.printHelp();
 }
 
 /// Utility function for printing version number.
 void cl::PrintVersionMessage() {
-  CommonOptions->VersionPrinterInstance.print();
+  getCommonOptions().VersionPrinterInstance.print();
 }
 
 void cl::SetVersionPrinter(VersionPrinterTy func) {
-  CommonOptions->OverrideVersionPrinter = func;
+  getCommonOptions().OverrideVersionPrinter = func;
 }
 
 void cl::AddExtraVersionPrinter(VersionPrinterTy func) {
-  CommonOptions->ExtraVersionPrinters.push_back(func);
+  getCommonOptions().ExtraVersionPrinters.push_back(func);
 }
 
 StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) {
   initCommonOptions();
-  auto &Subs = GlobalParser->RegisteredSubCommands;
+  auto &Subs = getGlobalParser().RegisteredSubCommands;
   (void)Subs;
   assert(is_contained(Subs, &Sub));
   return Sub.OptionsMap;
 }
 
 iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 cl::getRegisteredSubcommands() {
-  return GlobalParser->getRegisteredSubcommands();
+  return getGlobalParser().getRegisteredSubcommands();
 }
 
 void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) {
   initCommonOptions();
   for (auto &I : Sub.OptionsMap) {
     bool Unrelated = true;
     for (auto &Cat : I.second->Categories) {
-      if (Cat == &Category || Cat == &CommonOptions->GenericCategory)
+      if (Cat == &Category || Cat == &getCommonOptions().GenericCategory)
         Unrelated = false;
     }
     if (Unrelated)
       I.second->setHiddenFlag(cl::ReallyHidden);
   }
 }
 
 void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
                               SubCommand &Sub) {
   initCommonOptions();
   for (auto &I : Sub.OptionsMap) {
     bool Unrelated = true;
     for (auto &Cat : I.second->Categories) {
       if (is_contained(Categories, Cat) ||
-          Cat == &CommonOptions->GenericCategory)
+          Cat == &getCommonOptions().GenericCategory)
         Unrelated = false;
     }
     if (Unrelated)
       I.second->setHiddenFlag(cl::ReallyHidden);
   }
 }
 
-void cl::ResetCommandLineParser() { GlobalParser->reset(); }
+void cl::ResetCommandLineParser() { getGlobalParser().reset(); }
 void cl::ResetAllOptionOccurrences() {
-  GlobalParser->ResetAllOptionOccurrences();
+  getGlobalParser().ResetAllOptionOccurrences();
 }
 
 void LLVMParseCommandLineOptions(int argc, const char *const *argv,
                                  const char *Overview) {
   llvm::cl::ParseCommandLineOptions(argc, argv, StringRef(Overview),
                                     &llvm::nulls());
 }

llvm/lib/Target/ARM/ARMExpandPseudoInsts.cpp

 #include "ARMMachineFunctionInfo.h"
 #include "ARMSubtarget.h"
 #include "MCTargetDesc/ARMAddressingModes.h"
 #include "llvm/CodeGen/LivePhysRegs.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/Support/Debug.h"
+#include <atomic>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "arm-pseudo"
 
 static cl::opt<bool>
 VerifyARMPseudo("verify-arm-pseudo-expand", cl::Hidden,
                 cl::desc("Verify machine code after expanding ARM pseudos"));

llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp

 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MachineValueType.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <algorithm>
+#include <atomic>
 #include <cassert>
 #include <cstdint>
 #include <iterator>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>