Use ManagedStatic and lazy initialization of cl::opt in libSupport to make it free of global initializer

[mehdi_amini]

Summary

We can build it with -Werror=global-constructors now. This helps
in situation where libSupport is embedded as a shared library,
potential with dlopen/dlclose scenario, and when command-line
parsing or other facilities may not be involved. Avoiding the
implicit construction of these cl::opt can avoid double-registration
issues and other kind of behavior.

[jhenderson]

I've briefly skimmed this, and the general approach looks good. Unfortunately, I don't have the time to review this further at this point.

[lattner]

This is really great Mehdi, thank you for making libsupport be static ctor clean!

[jpienaar]

Nice!

llvm/lib/Support/Debug.cpp

83–84

Would it make sense to have these above the flags instead of above the structs?

94–109

Why not in anonymous namespace too? (consistenly everywhere)

llvm/lib/Support/DebugOptions.h

2

Missing c++?

31

rm?

[MaskRay]

If you have installed valgrind:

/home/maskray/llvm/llvm/lib/Support/Valgrind.cpp:30:19: error: declaration requires a global constructor [-Werror,-Wglobal-constructors]
static const bool NotUnderValgrind = InitNotUnderValgrind();

llvm/lib/Support/ARMBuildAttrs.cpp

13

This change is unrelated to removing dynamic initializations.

const objects at namespace level has internal linkage so you can omit static.

llvm/lib/Support/CMakeLists.txt

7

Perhaps move this to a separate change.

llvm/lib/Support/CommandLine.cpp

2439–2532

unnamed namespace

[mehdi_amini]

Address comment and fix build errors

[mehdi_amini]

llvm/lib/Support/CMakeLists.txt

7

Sure, I can commit this separately.

llvm/lib/Support/Debug.cpp

94–109

I think it is already?

[bondhugula]

This is a really welcome change! Multiple registration issues were really an inconvenience - I had no clue this was the pattern to use to fix it. Thanks!

[mehdi_amini]

Fix windows build

[mehdi_amini]

In D105959#2882099, @bondhugula wrote:

This is a really welcome change! Multiple registration issues were really an inconvenience - I had no clue this was the pattern to use to fix it. Thanks!

To be fair: we can do it transparently only for libSupport, as it contains the entry point for command line parsing it can explicitly trigger the registration of the options for itself. Other libraries in LLVM don't have this luxury...

[dexonsmith]

In D105959#2882136, @mehdi_amini wrote:

In D105959#2882099, @bondhugula wrote:

This is a really welcome change! Multiple registration issues were really an inconvenience - I had no clue this was the pattern to use to fix it. Thanks!

To be fair: we can do it transparently only for libSupport, as it contains the entry point for command line parsing it can explicitly trigger the registration of the options for itself. Other libraries in LLVM don't have this luxury...

We could probably combine this with the technique used to avoid static constructors in compiler-rt/lib/profile to pick up other libraries in the same final linked image. The idea would be to ask the linker to build an array of initializer functions that LLVMSupport could iterate through to initialize options it doesn't know about.

For example, on Darwin, this code adds an initializer to a global array in section __DATA,__llvmopts:

using OptionConstructorT = void (*)(); // Declared in LLVMSupport headers to get safety.

void initOptions();

// Add an options constructor the array of cl::opt initializers.
__attribute__((section("__DATA,__llvmopts"),visibility("hidden")))
OptionConstructorT OptionsConstructor = initOptions;

Also on Darwin, this could go in LLVMSupport to access it:

using OptionConstructorT = void (*)(); // Declared in LLVMSupport headers to get safety.

// Declare symbols to access the global array.
extern OptionConstructorT *ExternalOptionsInitBegin
  __asm("section$start$__DATA$__llvmopts");
extern OptionConstructorT *ExternalOptionsInitEnd
  __asm("section$end$__DATA$__llvmopts");

void initCommonOptions();
void initOptions() {
  initCommonOptions();
  // Iterate through external initializers for options.
  for (auto I = ExternalOptionsInitBegin, E = ExternalOptionsInitEnd; I != E; ++I)
    (*I)();
}

The relevant code for other platforms is in compiler-rt/lib/profile/InstrProfilingPlatform*.c.

If we did this, we'd maybe want to control it with a CMake configuration? When off (always for platforms where we don't have/know the magic incantations), the various initOptions() would be added to static initializers as before. When on, we could add -Werror=global-constructors to other libraries (once they're clean).

[mehdi_amini]

That's interesting!

I'm not sure how to get there though: a complete solution should be able to "degrade" to global constructor when the platform-specific logic isn't available (unless we're confident that no such environment can exist?).

[mehdi_amini]

Something else I'm not sure about is how it works across DSOs: when each LLVM library is linked into its own shared library, is the dynamic linker creating this array when loading the libraries?
(I'm starting to doubt about how this would even work on windows)

[jrtc27]

It's just a standard linker set; the static linker combines all the input sections containing the array elements into a single output section. It's similar to init_array etc, just without the special meaning (i.e. you have to write the code to iterate over the array and do what you want).

[dexonsmith]

In D105959#2883954, @mehdi_amini wrote:

That's interesting!

I'm not sure how to get there though: a complete solution should be able to "degrade" to global constructor when the platform-specific logic isn't available (unless we're confident that no such environment can exist?).

Right, it needs to downgrade (and I think there should be a CMake flag to turn it off in case there are reasons some LLVM user doesn't want it).

I think this would work:

#ifdef USE_DARWIN_CLOPT
// Add F to the list of initializers for LLVMSupport to iterate through.
#define LLVM_ADD_CLOPT_CONSTRUCTOR(F, V) \
  __attribute__((section("__DATA,__llvmopts"),visibility("hidden"))) \
  void (*V)() = F;
#elif defined(...) // Handle magic for other platforms.
#else
// Create a local symbol with a static initializer that calls F.
#define LLVM_ADD_CLOPT_CONSTRUCTOR(F, V) \
  namespace { struct V##Type { V##Type() { F(); } } V; }
#endif

void initOptions();
// Add an options constructor the array of cl::opt initializers.
LLVM_ADD_CLOPT_CONSTRUCTOR(initOptions, OptionsConstructorVariable);

but maybe there's a cleaner downgrade that doesn't add an extra type.

In D105959#2883956, @mehdi_amini wrote:

Something else I'm not sure about is how it works across DSOs: when each LLVM library is linked into its own shared library, is the dynamic linker creating this array when loading the libraries? (I'm starting to doubt about how this would even work on windows)

Yeah, this technique only works within a single final linked image. It'd need to be off when the library isn't statically linked to LLVMSupport.

I imagine we'd want CMake to just "get this right" for us, but we can also enforce this at link time to catch configuration errors -- add a (dead-strippable) symbol to LLVMSupport that's visibility("hidden"), and manufacture a (dead-strippable) reference to it in any TU that uses the macro. If the TU ends up in a different linked image than LLVMSupport you'll get a link error.

clang-tools-extra/clangd/index/dex/dexp/Dexp.cpp

 }
 
 // REPL commands inherit from Command and contain their options as members.
 // Creating a Command populates parser options, parseAndRun() resets them.
 class Command {
   // By resetting the parser options, we lost the standard -help flag.
   llvm::cl::opt<bool, false, llvm::cl::parser<bool>> Help{
       "help", llvm::cl::desc("Display available options"),
-      llvm::cl::ValueDisallowed, llvm::cl::cat(llvm::cl::GeneralCategory)};
+      llvm::cl::ValueDisallowed, llvm::cl::cat(llvm::cl::getGeneralCategory())};
   // FIXME: Allow commands to signal failure.
   virtual void run() = 0;
 
 protected:
   const SymbolIndex *Index;
 
 public:
   virtual ~Command() = default;

clang-tools-extra/clangd/indexer/IndexerMain.cpp

int main(int argc, const char **argv) {
   Example usage for file sequence index without flags:
 
   $ clangd-indexer File1.cpp File2.cpp ... FileN.cpp > clangd.dex
 
   Note: only symbols from header files will be indexed.
   )";
 
   auto Executor = clang::tooling::createExecutorFromCommandLineArgs(
-      argc, argv, llvm::cl::GeneralCategory, Overview);
+      argc, argv, llvm::cl::getGeneralCategory(), Overview);
 
   if (!Executor) {
     llvm::errs() << llvm::toString(Executor.takeError()) << "\n";
     return 1;
   }
 
   // Collect symbols found in each translation unit, merging as we go.
   clang::clangd::IndexFileIn Data;

clang/tools/clang-refactor/ClangRefactor.cpp

 using namespace refactor;
 namespace cl = llvm::cl;
 
 namespace opts {
 
 static cl::OptionCategory CommonRefactorOptions("Refactoring options");
 
 static cl::opt<bool> Verbose("v", cl::desc("Use verbose output"),
-                             cl::cat(cl::GeneralCategory),
+                             cl::cat(cl::getGeneralCategory()),
                              cl::sub(*cl::AllSubCommands));
 
 static cl::opt<bool> Inplace("i", cl::desc("Inplace edit <file>s"),
-                             cl::cat(cl::GeneralCategory),
+                             cl::cat(cl::getGeneralCategory()),
                              cl::sub(*cl::AllSubCommands));
 
 } // end namespace opts
 
 namespace {
 
 /// Stores the parsed `-selection` argument.
 class SourceSelectionArgument {

 } // end anonymous namespace
 
 int main(int argc, const char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
 
   ClangRefactorTool RefactorTool;
 
   auto ExpectedParser = CommonOptionsParser::create(
-      argc, argv, cl::GeneralCategory, cl::ZeroOrMore,
+      argc, argv, cl::getGeneralCategory(), cl::ZeroOrMore,
       "Clang-based refactoring tool for C, C++ and Objective-C");
   if (!ExpectedParser) {
     llvm::errs() << ExpectedParser.takeError();
     return 1;
   }
   CommonOptionsParser &Options = ExpectedParser.get();
 
   if (auto Err = RefactorTool.Init()) {

llvm/docs/CommandLine.rst

These control which stages are run.
       -E                 - Run preprocessor stage.
       -c                 - Run all stages except linking.
 
 In addition to the behaviour of ``-help`` changing when an option category is
 declared, the command line option ``-help-list`` becomes visible which will
 print the command line options as uncategorized list.
 
 Note that Options that are not explicitly categorized will be placed in the
-``cl::GeneralCategory`` category.
+``cl::getGeneralCategory()`` category.
 
 .. _Reference Guide:
 
 Reference Guide
 ===============
 
 Now that you know the basics of how to use the CommandLine library, this section
 will give you the detailed information you need to tune how command line options

llvm/include/llvm/Support/ARMAttributeParser.h

class ARMAttributeParser : public ELFAttributeParser {
   Error DIV_use(ARMBuildAttrs::AttrType tag);
   Error DSP_extension(ARMBuildAttrs::AttrType tag);
   Error T2EE_use(ARMBuildAttrs::AttrType tag);
   Error Virtualization_use(ARMBuildAttrs::AttrType tag);
   Error nodefaults(ARMBuildAttrs::AttrType tag);
 
 public:
   ARMAttributeParser(ScopedPrinter *sw)
-      : ELFAttributeParser(sw, ARMBuildAttrs::ARMAttributeTags, "aeabi") {}
+      : ELFAttributeParser(sw, ARMBuildAttrs::getARMAttributeTags(), "aeabi") {}
   ARMAttributeParser()
-      : ELFAttributeParser(ARMBuildAttrs::ARMAttributeTags, "aeabi") {}
+      : ELFAttributeParser(ARMBuildAttrs::getARMAttributeTags(), "aeabi") {}
 };
 }
 
 #endif

llvm/include/llvm/Support/ARMBuildAttributes.h

 #ifndef LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
 #define LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
 
 #include "llvm/Support/ELFAttributes.h"
 
 namespace llvm {
 namespace ARMBuildAttrs {
 
-extern const TagNameMap ARMAttributeTags;
+const TagNameMap &getARMAttributeTags();
 
 enum SpecialAttr {
   // This is for the .cpu asm attr. It translates into one or more
   // AttrType (below) entries in the .ARM.attributes section in the ELF.
   SEL_CPU
 };
 
 enum AttrType : unsigned {

llvm/include/llvm/Support/CommandLine.h

OptionCategory(StringRef const Name,
     registerCategory();
   }
 
   StringRef getName() const { return Name; }
   StringRef getDescription() const { return Description; }
 };
 
 // The general Option Category (used as default category).
-extern OptionCategory GeneralCategory;
+OptionCategory &getGeneralCategory();
 
 //===----------------------------------------------------------------------===//
 // SubCommand class
 //
 class SubCommand {
 private:
   StringRef Name;
   StringRef Description;
public:
   void addSubCommand(SubCommand &S) { Subs.insert(&S); }
 
 protected:
   explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
                   enum OptionHidden Hidden)
       : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
         HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0),
         FullyInitialized(false), Position(0), AdditionalVals(0) {
-    Categories.push_back(&GeneralCategory);
+    Categories.push_back(&getGeneralCategory());
   }
 
   inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
 
 public:
   virtual ~Option() = default;
 
   // addArgument - Register this argument with the commandline system.

llvm/include/llvm/Support/RISCVAttributeParser.h

class RISCVAttributeParser : public ELFAttributeParser {
 
   Error handler(uint64_t tag, bool &handled) override;
 
   Error unalignedAccess(unsigned tag);
   Error stackAlign(unsigned tag);
 
 public:
   RISCVAttributeParser(ScopedPrinter *sw)
-      : ELFAttributeParser(sw, RISCVAttrs::RISCVAttributeTags, "riscv") {}
+      : ELFAttributeParser(sw, RISCVAttrs::getRISCVAttributeTags(), "riscv") {}
   RISCVAttributeParser()
-      : ELFAttributeParser(RISCVAttrs::RISCVAttributeTags, "riscv") {}
+      : ELFAttributeParser(RISCVAttrs::getRISCVAttributeTags(), "riscv") {}
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/RISCVAttributes.h

 #ifndef LLVM_SUPPORT_RISCVATTRIBUTES_H
 #define LLVM_SUPPORT_RISCVATTRIBUTES_H
 
 #include "llvm/Support/ELFAttributes.h"
 
 namespace llvm {
 namespace RISCVAttrs {
 
-extern const TagNameMap RISCVAttributeTags;
+const TagNameMap &getRISCVAttributeTags();
 
 enum AttrType : unsigned {
   // Attribute types in ELF/.riscv.attributes.
   STACK_ALIGN = 4,
   ARCH = 5,
   UNALIGNED_ACCESS = 6,
   PRIV_SPEC = 8,
   PRIV_SPEC_MINOR = 10,

llvm/include/llvm/Support/ScopedPrinter.h

template <typename T> struct EnumEntry {
   // GNU style and LLVM style of ELFDumper do not
   // display same string for same enum. The AltName if initialized appropriately
   // will hold the string that GNU style emits.
   // Example:
   // "EM_X86_64" string on LLVM style for Elf_Ehdr->e_machine corresponds to
   // "Advanced Micro Devices X86-64" on GNU style
   StringRef AltName;
   T Value;
-  EnumEntry(StringRef N, StringRef A, T V) : Name(N), AltName(A), Value(V) {}
-  EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {}
+  constexpr EnumEntry(StringRef N, StringRef A, T V)
+      : Name(N), AltName(A), Value(V) {}
+  constexpr EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {}
 };
 
 struct HexNumber {
   // To avoid sign-extension we have to explicitly cast to the appropriate
   // unsigned type. The overloads are here so that every type that is implicitly
   // convertible to an integer (including enums and endian helpers) can be used
   // without requiring type traits or call-site changes.
   HexNumber(char Value) : Value(static_cast<unsigned char>(Value)) {}

llvm/include/llvm/Support/WithColor.h

 
 class Error;
 class StringRef;
 
 namespace cl {
 class OptionCategory;
 }
 
-extern cl::OptionCategory ColorCategory;
+extern cl::OptionCategory &getColorCategory();
 
 // Symbolic names for various syntax elements.
 enum class HighlightColor {
   Address,
   String,
   Tag,
   Attribute,
   Enumerator,

llvm/lib/Support/ARMBuildAttrs.cpp

 //===-- ARMBuildAttrs.cpp - ARM Build Attributes --------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/ARMBuildAttributes.h"
 
 using namespace llvm;
 
 static const TagNameItem tagData[] = {
     {ARMBuildAttrs::File, "Tag_File"},
     {ARMBuildAttrs::Section, "Tag_Section"},
     {ARMBuildAttrs::Symbol, "Tag_Symbol"},
     {ARMBuildAttrs::CPU_raw_name, "Tag_CPU_raw_name"},
     {ARMBuildAttrs::CPU_name, "Tag_CPU_name"},
     {ARMBuildAttrs::CPU_arch, "Tag_CPU_arch"},
     {ARMBuildAttrs::CPU_arch_profile, "Tag_CPU_arch_profile"},
     {ARMBuildAttrs::ARM_ISA_use, "Tag_ARM_ISA_use"},
static const TagNameItem tagData[] = {
 
     // Legacy Names
     {ARMBuildAttrs::FP_arch, "Tag_VFP_arch"},
     {ARMBuildAttrs::FP_HP_extension, "Tag_VFP_HP_extension"},
     {ARMBuildAttrs::ABI_align_needed, "Tag_ABI_align8_needed"},
     {ARMBuildAttrs::ABI_align_preserved, "Tag_ABI_align8_preserved"},
 };
 
-const TagNameMap llvm::ARMBuildAttrs::ARMAttributeTags(tagData,
-                                                       sizeof(tagData) /
-                                                           sizeof(TagNameItem));
+constexpr TagNameMap ARMAttributeTags{tagData};
+const TagNameMap &llvm::ARMBuildAttrs::getARMAttributeTags() {
+  return ARMAttributeTags;
+}

llvm/lib/Support/CMakeLists.txt

 include(GetLibraryName)
 
+# Ensure that libSupport does not carry any static global initializer.
+# libSupport can be embedded in use cases where we don't want to load all
+# cl::opt unless we want to parse the command line. 
+# ManagedStatic can be used to enable lazy-initialization of globals.
+add_flag_if_supported("-Werror=global-constructors" WERROR_GLOBAL_CONSTRUCTOR)
+
 if(LLVM_ENABLE_ZLIB)
   set(imported_libs ZLIB::ZLIB)
 endif()
 
 if( MSVC OR MINGW )
   # libuuid required for FOLDERID_Profile usage in lib/Support/Windows/Path.inc.
   # advapi32 required for CryptAcquireContextW in lib/Support/Windows/Path.inc.
   set(system_libs ${system_libs} psapi shell32 ole32 uuid advapi32)

llvm/lib/Support/CommandLine.cpp

 // extensible and supports nonlocal (library) command line options.
 //
 // Note that rather than trying to figure out what this code does, you could try
 // reading the library documentation located in docs/CommandLine.html
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/CommandLine.h"
+
+#include "DebugOptions.h"
+
 #include "llvm-c/Support.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
if (ArgStr.size() == 1)
     setMiscFlag(Grouping);
 }
 
 void Option::addCategory(OptionCategory &C) {
   assert(!Categories.empty() && "Categories cannot be empty.");
   // Maintain backward compatibility by replacing the default GeneralCategory
   // if it's still set.  Otherwise, just add the new one.  The GeneralCategory
   // must be explicitly added if you want multiple categories that include it.
-  if (&C != &GeneralCategory && Categories[0] == &GeneralCategory)
+  if (&C != &getGeneralCategory() && Categories[0] == &getGeneralCategory())
     Categories[0] = &C;
   else if (!is_contained(Categories, &C))
     Categories.push_back(&C);
 }
 
 void Option::reset() {
   NumOccurrences = 0;
   setDefault();
   if (isDefaultOption())
     removeArgument();
 }
 
-// Initialise the general option category.
-OptionCategory llvm::cl::GeneralCategory("General options");
-
 void OptionCategory::registerCategory() {
   GlobalParser->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.
if (llvm::Error Err =
     // TODO: The error should be propagated up the stack.
     llvm::consumeError(std::move(Err));
     return false;
   }
   return ExpandResponseFiles(Saver, cl::tokenizeConfigFile, Argv,
                              /*MarkEOLs=*/false, /*RelativeNames=*/true);
 }
 
+static void initCommonOptions();
 bool cl::ParseCommandLineOptions(int argc, const char *const *argv,
                                  StringRef Overview, raw_ostream *Errs,
                                  const char *EnvVar,
                                  bool LongOptionsUseDoubleDash) {
+  initCommonOptions();
   SmallVector<const char *, 20> NewArgv;
   BumpPtrAllocator A;
   StringSaver Saver(A);
   NewArgv.push_back(argv[0]);
 
   // Parse options from environment variable.
   if (EnvVar) {
     if (llvm::Optional<std::string> EnvValue =
if (getOption(i) == Name)
       return i;
   }
   return e;
 }
 
 static StringRef EqValue = "=<value>";
 static StringRef EmptyOption = "<empty>";
 static StringRef OptionPrefix = "    =";
-static size_t OptionPrefixesSize = OptionPrefix.size() + ArgHelpPrefix.size();
+static size_t getOptionPrefixesSize() {
+  return OptionPrefix.size() + ArgHelpPrefix.size();
+}
 
 static bool shouldPrintOption(StringRef Name, StringRef Description,
                               const Option &O) {
   return O.getValueExpectedFlag() != ValueOptional || !Name.empty() ||
          !Description.empty();
 }
 
 // Return the width of the option tag for printing...
 size_t generic_parser_base::getOptionWidth(const Option &O) const {
   if (O.hasArgStr()) {
     size_t Size =
         argPlusPrefixesSize(O.ArgStr) + EqValue.size();
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
       StringRef Name = getOption(i);
       if (!shouldPrintOption(Name, getDescription(i), O))
         continue;
       size_t NameSize = Name.empty() ? EmptyOption.size() : Name.size();
-      Size = std::max(Size, NameSize + OptionPrefixesSize);
+      Size = std::max(Size, NameSize + getOptionPrefixesSize());
     }
     return Size;
   } else {
     size_t BaseSize = 0;
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
       BaseSize = std::max(BaseSize, getOption(i).size() + 8);
     return BaseSize;
   }
if (O.hasArgStr()) {
     Option::printHelpStr(O.HelpStr, GlobalWidth,
                          EqValue.size() +
                              argPlusPrefixesSize(O.ArgStr));
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
       StringRef OptionName = getOption(i);
       StringRef Description = getDescription(i);
       if (!shouldPrintOption(OptionName, Description, O))
         continue;
-      size_t FirstLineIndent = OptionName.size() + OptionPrefixesSize;
+      size_t FirstLineIndent = OptionName.size() + getOptionPrefixesSize();
       outs() << OptionPrefix << OptionName;
       if (OptionName.empty()) {
         outs() << EmptyOption;
         assert(FirstLineIndent >= EmptyOption.size());
         FirstLineIndent += EmptyOption.size();
       }
       if (!Description.empty())
         Option::printEnumValHelpStr(Description, GlobalWidth, FirstLineIndent);
explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter,
         CategorizedPrinter(CategorizedPrinter) {}
 
   // Invoke the printer.
   void operator=(bool Value);
 };
 
 } // End anonymous namespace
 
-// Declare the four HelpPrinter instances that are used to print out help, or
-// help-hidden as an uncategorized list or in categories.
-static HelpPrinter UncategorizedNormalPrinter(false);
-static HelpPrinter UncategorizedHiddenPrinter(true);
-static CategorizedHelpPrinter CategorizedNormalPrinter(false);
-static CategorizedHelpPrinter CategorizedHiddenPrinter(true);
-
-// Declare HelpPrinter wrappers that will decide whether or not to invoke
-// a categorizing help printer
-static HelpPrinterWrapper WrappedNormalPrinter(UncategorizedNormalPrinter,
-                                               CategorizedNormalPrinter);
-static HelpPrinterWrapper WrappedHiddenPrinter(UncategorizedHiddenPrinter,
-                                               CategorizedHiddenPrinter);
-
-// Define a category for generic options that all tools should have.
-static cl::OptionCategory GenericCategory("Generic Options");
-
-// Define uncategorized help printers.
-// --help-list is hidden by default because if Option categories are being used
-// then --help behaves the same as --help-list.
-static cl::opt<HelpPrinter, true, parser<bool>> HLOp(
-    "help-list",
-    cl::desc("Display list of available options (--help-list-hidden for more)"),
-    cl::location(UncategorizedNormalPrinter), cl::Hidden, cl::ValueDisallowed,
-    cl::cat(GenericCategory), cl::sub(*AllSubCommands));
-
-static cl::opt<HelpPrinter, true, parser<bool>>
-    HLHOp("help-list-hidden", cl::desc("Display list of all available options"),
-          cl::location(UncategorizedHiddenPrinter), cl::Hidden,
-          cl::ValueDisallowed, cl::cat(GenericCategory),
-          cl::sub(*AllSubCommands));
-
-// Define uncategorized/categorized help printers. These printers change their
-// behaviour at runtime depending on whether one or more Option categories have
-// been declared.
-static cl::opt<HelpPrinterWrapper, true, parser<bool>>
-    HOp("help", cl::desc("Display available options (--help-hidden for more)"),
-        cl::location(WrappedNormalPrinter), cl::ValueDisallowed,
-        cl::cat(GenericCategory), cl::sub(*AllSubCommands));
-
-static cl::alias HOpA("h", cl::desc("Alias for --help"), cl::aliasopt(HOp),
-                      cl::DefaultOption);
-
-static cl::opt<HelpPrinterWrapper, true, parser<bool>>
-    HHOp("help-hidden", cl::desc("Display all available options"),
-         cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed,
-         cl::cat(GenericCategory), cl::sub(*AllSubCommands));
-
-static cl::opt<bool> PrintOptions(
-    "print-options",
-    cl::desc("Print non-default options after command line parsing"),
-    cl::Hidden, cl::init(false), cl::cat(GenericCategory),
-    cl::sub(*AllSubCommands));
-
-static cl::opt<bool> PrintAllOptions(
-    "print-all-options",
-    cl::desc("Print all option values after command line parsing"), cl::Hidden,
-    cl::init(false), cl::cat(GenericCategory), cl::sub(*AllSubCommands));
-
-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) {
-    // unhide --help-list option so user can have uncategorized output if they
-    // want it.
-    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 CommandLineParser::printOptionValues() {
-  if (!PrintOptions && !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, PrintAllOptions);
-}
-
-static VersionPrinterTy OverrideVersionPrinter = nullptr;
-
-static std::vector<VersionPrinterTy> *ExtraVersionPrinters = nullptr;
-
 #if defined(__GNUC__)
 // GCC and GCC-compatible compilers define __OPTIMIZE__ when optimizations are
 // enabled.
 # if defined(__OPTIMIZE__)
 #  define LLVM_IS_DEBUG_BUILD 0
 # else
 #  define LLVM_IS_DEBUG_BUILD 1
 # endif
#if LLVM_VERSION_PRINTER_SHOW_HOST_TARGET_INFO
     if (CPU == "generic")
       CPU = "(unknown)";
     OS << ".\n"
        << "  Default target: " << sys::getDefaultTargetTriple() << '\n'
        << "  Host CPU: " << CPU;
 #endif
     OS << '\n';
   }
-  void operator=(bool OptionWasSpecified) {
-    if (!OptionWasSpecified)
-      return;
+  void operator=(bool OptionWasSpecified);
+};
+
+struct CommandLineCommonOptions {
+  // Declare the four HelpPrinter instances that are used to print out help, or
+  // help-hidden as an uncategorized list or in categories.
+  HelpPrinter UncategorizedNormalPrinter{false};
+  HelpPrinter UncategorizedHiddenPrinter{true};
+  CategorizedHelpPrinter CategorizedNormalPrinter{false};
+  CategorizedHelpPrinter CategorizedHiddenPrinter{true};
+  // Declare HelpPrinter wrappers that will decide whether or not to invoke
+  // a categorizing help printer
+  HelpPrinterWrapper WrappedNormalPrinter{UncategorizedNormalPrinter,
+                                          CategorizedNormalPrinter};
+  HelpPrinterWrapper WrappedHiddenPrinter{UncategorizedHiddenPrinter,
+                                          CategorizedHiddenPrinter};
+  // Define a category for generic options that all tools should have.
+  cl::OptionCategory GenericCategory{"Generic Options"};
+
+  // Define uncategorized help printers.
+  // --help-list is hidden by default because if Option categories are being
+  // used then --help behaves the same as --help-list.
+  cl::opt<HelpPrinter, true, parser<bool>> HLOp{
+      "help-list",
+      cl::desc(
+          "Display list of available options (--help-list-hidden for more)"),
+      cl::location(UncategorizedNormalPrinter),
+      cl::Hidden,
+      cl::ValueDisallowed,
+      cl::cat(GenericCategory),
+      cl::sub(*AllSubCommands)};
+
+  cl::opt<HelpPrinter, true, parser<bool>> HLHOp{
+      "help-list-hidden",
+      cl::desc("Display list of all available options"),
+      cl::location(UncategorizedHiddenPrinter),
+      cl::Hidden,
+      cl::ValueDisallowed,
+      cl::cat(GenericCategory),
+      cl::sub(*AllSubCommands)};
+
+  // Define uncategorized/categorized help printers. These printers change their
+  // behaviour at runtime depending on whether one or more Option categories
+  // have been declared.
+  cl::opt<HelpPrinterWrapper, true, parser<bool>> HOp{
+      "help",
+      cl::desc("Display available options (--help-hidden for more)"),
+      cl::location(WrappedNormalPrinter),
+      cl::ValueDisallowed,
+      cl::cat(GenericCategory),
+      cl::sub(*AllSubCommands)};
+
+  cl::alias HOpA{"h", cl::desc("Alias for --help"), cl::aliasopt(HOp),
+                 cl::DefaultOption};
+
+  cl::opt<HelpPrinterWrapper, true, parser<bool>> HHOp{
+      "help-hidden",
+      cl::desc("Display all available options"),
+      cl::location(WrappedHiddenPrinter),
+      cl::Hidden,
+      cl::ValueDisallowed,
+      cl::cat(GenericCategory),
+      cl::sub(*AllSubCommands)};
+
+  cl::opt<bool> PrintOptions{
+      "print-options",
+      cl::desc("Print non-default options after command line parsing"),
+      cl::Hidden,
+      cl::init(false),
+      cl::cat(GenericCategory),
+      cl::sub(*AllSubCommands)};
+
+  cl::opt<bool> PrintAllOptions{
+      "print-all-options",
+      cl::desc("Print all option values after command line parsing"),
+      cl::Hidden,
+      cl::init(false),
+      cl::cat(GenericCategory),
+      cl::sub(*AllSubCommands)};
+
+  VersionPrinterTy OverrideVersionPrinter = nullptr;
+
+  std::vector<VersionPrinterTy> ExtraVersionPrinters;
+
+  // 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 void initCommonOptions() {
+  *CommonOptions;
+  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 (OverrideVersionPrinter != nullptr) {
-      OverrideVersionPrinter(outs());
-      exit(0);
-    }
-    print();
+  if (CommonOptions->OverrideVersionPrinter != nullptr) {
+    CommonOptions->OverrideVersionPrinter(outs());
 
-    // Iterate over any registered extra printers and call them to add further
-    // information.
-    if (ExtraVersionPrinters != nullptr) {
-      outs() << '\n';
-      for (const auto &I : *ExtraVersionPrinters)
-        I(outs());
-    }
+  if (!CommonOptions->ExtraVersionPrinters.empty()) {
+    for (const auto &I : CommonOptions->ExtraVersionPrinters)
 
-    exit(0);
-  }
-};
-} // End anonymous namespace
 
-// Define the --version option that prints out the LLVM version for the tool
-static VersionPrinter VersionPrinterInstance;
+void HelpPrinterWrapper::operator=(bool Value) {
+  if (!Value)
+    return;
 
-static cl::opt<VersionPrinter, true, parser<bool>>
-    VersOp("version", cl::desc("Display the version of this program"),
-           cl::location(VersionPrinterInstance), cl::ValueDisallowed,
-           cl::cat(GenericCategory));
+  // 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) {
+    // unhide --help-list option so user can have uncategorized output if they
+    // want it.
+    CommonOptions->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 CommandLineParser::printOptionValues() {
+  if (!CommonOptions->PrintOptions && !CommonOptions->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);
+}
 
 // Utility function for printing the help message.
 void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
   if (!Hidden && !Categorized)
-    UncategorizedNormalPrinter.printHelp();
+    CommonOptions->UncategorizedNormalPrinter.printHelp();
   else if (!Hidden && Categorized)
-    CategorizedNormalPrinter.printHelp();
+    CommonOptions->CategorizedNormalPrinter.printHelp();
   else if (Hidden && !Categorized)
-    UncategorizedHiddenPrinter.printHelp();
+    CommonOptions->UncategorizedHiddenPrinter.printHelp();
   else
-    CategorizedHiddenPrinter.printHelp();
+    CommonOptions->CategorizedHiddenPrinter.printHelp();
 }
 
 /// Utility function for printing version number.
-void cl::PrintVersionMessage() { VersionPrinterInstance.print(); }
+void cl::PrintVersionMessage() {
+  CommonOptions->VersionPrinterInstance.print();
+}
 
-void cl::SetVersionPrinter(VersionPrinterTy func) { OverrideVersionPrinter = func; }
+void cl::SetVersionPrinter(VersionPrinterTy func) {
+  CommonOptions->OverrideVersionPrinter = func;
+}
 
 void cl::AddExtraVersionPrinter(VersionPrinterTy func) {
-  if (!ExtraVersionPrinters)
-    ExtraVersionPrinters = new std::vector<VersionPrinterTy>;
-
-  ExtraVersionPrinters->push_back(func);
+  CommonOptions->ExtraVersionPrinters.push_back(func);
 }
 
 StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) {
   auto &Subs = GlobalParser->RegisteredSubCommands;
   (void)Subs;
   assert(is_contained(Subs, &Sub));
   return Sub.OptionsMap;
 }
 
 iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 cl::getRegisteredSubcommands() {
   return GlobalParser->getRegisteredSubcommands();
 }
 
 void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) {
+  initCommonOptions();
   for (auto &I : Sub.OptionsMap) {
     for (auto &Cat : I.second->Categories) {
-      if (Cat != &Category &&
-          Cat != &GenericCategory)
+      if (Cat != &Category && Cat != &CommonOptions->GenericCategory)
         I.second->setHiddenFlag(cl::ReallyHidden);
     }
   }
 }
 
 void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
                               SubCommand &Sub) {
+  initCommonOptions();
   for (auto &I : Sub.OptionsMap) {
     for (auto &Cat : I.second->Categories) {
-      if (!is_contained(Categories, Cat) && Cat != &GenericCategory)
+      if (!is_contained(Categories, Cat) &&
+          Cat != &CommonOptions->GenericCategory)
         I.second->setHiddenFlag(cl::ReallyHidden);
     }
   }
 }
 
 void cl::ResetCommandLineParser() { GlobalParser->reset(); }
 void cl::ResetAllOptionOccurrences() {
   GlobalParser->ResetAllOptionOccurrences();
 }
 
 void LLVMParseCommandLineOptions(int argc, const char *const *argv,
                                  const char *Overview) {
   llvm::cl::ParseCommandLineOptions(argc, argv, StringRef(Overview),
                                     &llvm::nulls());
 }

llvm/lib/Support/Debug.cpp

 
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/circular_raw_ostream.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include "DebugOptions.h"
+
 #undef isCurrentDebugType
 #undef setCurrentDebugType
 #undef setCurrentDebugTypes
 
 using namespace llvm;
 
 // Even though LLVM might be built with NDEBUG, define symbols that the code
 // built without NDEBUG can depend on via the llvm/Support/Debug.h header.
void setCurrentDebugTypes(const char **Types, unsigned Count) {
   CurrentDebugType->clear();
   for (size_t T = 0; T < Count; ++T)
     CurrentDebugType->push_back(Types[T]);
 }
 } // namespace llvm
 
 // All Debug.h functionality is a no-op in NDEBUG mode.
 #ifndef NDEBUG
 
-// -debug - Command line option to enable the DEBUG statements in the passes.
-// This flag may only be enabled in debug builds.
-static cl::opt<bool, true>
-Debug("debug", cl::desc("Enable debug output"), cl::Hidden,
-      cl::location(DebugFlag));
+namespace {
+struct CreateDebug {
+  static void *call() {
+    return new cl::opt<bool, true>("debug", cl::desc("Enable debug output"),
+                                   cl::Hidden, cl::location(DebugFlag));
+  }
+};
 
 // -debug-buffer-size - Buffer the last N characters of debug output
 //until program termination.
-static cl::opt<unsigned>
-DebugBufferSize("debug-buffer-size",
-                cl::desc("Buffer the last N characters of debug output "
-                         "until program termination. "
-                         "[default 0 -- immediate print-out]"),
-                cl::Hidden,
-                cl::init(0));
+struct CreateDebugBufferSize {
+  static void *call() {
+    return new cl::opt<unsigned>(
+        "debug-buffer-size",
+        cl::Hidden, cl::init(0));
+  }
+};
+} // namespace
+
+// -debug - Command line option to enable the DEBUG statements in the passes.
+// This flag may only be enabled in debug builds.
+static ManagedStatic<cl::opt<bool, true>, CreateDebug> Debug;
+static ManagedStatic<cl::opt<unsigned>, CreateDebugBufferSize> DebugBufferSize;
 
 namespace {
 
 struct DebugOnlyOpt {
   void operator=(const std::string &Val) const {
     if (Val.empty())
       return;
     DebugFlag = true;
     SmallVector<StringRef,8> dbgTypes;
     StringRef(Val).split(dbgTypes, ',', -1, false);
     for (auto dbgType : dbgTypes)
       CurrentDebugType->push_back(std::string(dbgType));
   }
 };
-
 } // namespace
 
 static DebugOnlyOpt DebugOnlyOptLoc;
 
-static cl::opt<DebugOnlyOpt, true, cl::parser<std::string> >
-DebugOnly("debug-only", cl::desc("Enable a specific type of debug output (comma separated list of types)"),
-          cl::Hidden, cl::ZeroOrMore, cl::value_desc("debug string"),
-          cl::location(DebugOnlyOptLoc), cl::ValueRequired);
+namespace {
+struct CreateDebugOnly {
+  static void *call() {
+    return new cl::opt<DebugOnlyOpt, true, cl::parser<std::string>>(
+        "debug-only",
+        cl::desc("Enable a specific type of debug output (comma separated list "
+                 "of types)"),
+  }
+};
+} // namespace
+
+static ManagedStatic<cl::opt<DebugOnlyOpt, true, cl::parser<std::string>>,
+                     CreateDebugOnly>
+    DebugOnly;
+
+void llvm::initDebugOptions() {
+  *Debug;
+  *DebugBufferSize;
+  *DebugOnly;
+}
+
 // Signal handlers - dump debug output on termination.
 static void debug_user_sig_handler(void *Cookie) {
   // This is a bit sneaky.  Since this is under #ifndef NDEBUG, we
   // know that debug mode is enabled and dbgs() really is a
   // circular_raw_ostream.  If NDEBUG is defined, then dbgs() ==
   // errs() but this will never be invoked.
   llvm::circular_raw_ostream &dbgout =
       static_cast<circular_raw_ostream &>(llvm::dbgs());
   dbgout.flushBufferWithBanner();
 }
 
 /// dbgs - Return a circular-buffered debug stream.
 raw_ostream &llvm::dbgs() {
   // Do one-time initialization in a thread-safe way.
   static struct dbgstream {
     circular_raw_ostream strm;
 
-    dbgstream() :
-        strm(errs(), "*** Debug Log Output ***\n",
-             (!EnableDebugBuffering || !DebugFlag) ? 0 : DebugBufferSize) {
-      if (EnableDebugBuffering && DebugFlag && DebugBufferSize != 0)
+    dbgstream()
+        : strm(errs(), "*** Debug Log Output ***\n",
+               (!EnableDebugBuffering || !DebugFlag) ? 0 : *DebugBufferSize) {
+      if (EnableDebugBuffering && DebugFlag && *DebugBufferSize != 0)
         // TODO: Add a handler for SIGUSER1-type signals so the user can
         // force a debug dump.
         sys::AddSignalHandler(&debug_user_sig_handler, nullptr);
       // Otherwise we've already set the debug stream buffer size to
       // zero, disabling buffering so it will output directly to errs().
     }
   } thestrm;
 

llvm/lib/Support/DebugCounter.cpp

 #include "llvm/Support/DebugCounter.h"
+
+#include "DebugOptions.h"
+
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 
 namespace {
 // This class overrides the default list implementation of printing so we
for (const auto &Name : CounterInstance) {
       const auto Info =
           CounterInstance.getCounterInfo(CounterInstance.getCounterId(Name));
       size_t NumSpaces = GlobalWidth - Info.first.size() - 8;
       outs() << "    =" << Info.first;
       outs().indent(NumSpaces) << " -   " << Info.second << '\n';
     }
   }
 };
-} // namespace
 
-// Create our command line option.
-static DebugCounterList DebugCounterOption(
+struct CreateDebugCounterOption {
+  static void *call() {
+    return new DebugCounterList(
         "debug-counter", cl::Hidden,
         cl::desc("Comma separated list of debug counter skip and count"),
-    cl::CommaSeparated, cl::ZeroOrMore, cl::location(DebugCounter::instance()));
+        cl::CommaSeparated, cl::ZeroOrMore,
+        cl::location(DebugCounter::instance()));
+  }
+};
+} // namespace
 
-static cl::opt<bool> PrintDebugCounter(
-    "print-debug-counter", cl::Hidden, cl::init(false), cl::Optional,
+static ManagedStatic<DebugCounterList, CreateDebugCounterOption>
+    DebugCounterOption;
+static bool PrintDebugCounter;
+
+void llvm::initDebugCounterOptions() {
+  *DebugCounterOption;
+  static cl::opt<bool, true> RegisterPrintDebugCounter(
+      "print-debug-counter", cl::Hidden, cl::location(PrintDebugCounter),
+      cl::init(false), cl::Optional,
       cl::desc("Print out debug counter info after all counters accumulated"));
+}
 
 static ManagedStatic<DebugCounter> DC;
 
 // Print information when destroyed, iff command line option is specified.
 DebugCounter::~DebugCounter() {
   if (isCountingEnabled() && PrintDebugCounter)
     print(dbgs());
 }

llvm/lib/Support/DebugOptions.h

+//===-- DebugOptions.h - Global Command line opt for libSupport  *- 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 defines the entry point to initialize the options registered on the
+// command line for libSupport, this is internal to libSupport.
+//
+//===----------------------------------------------------------------------===//
+
+namespace llvm {
+
+// These are invoked internally before parsing command line options.
+// This enables lazy-initialization of all the globals in libSupport, instead
+// of eagerly loading everything on program startup.
+void initDebugCounterOptions();
+void initGraphWriterOptions();
+void initSignalsOptions();
+void initStatisticOptions();
+void initTimerOptions();
+void initTypeSizeOptions();
+void initWithColorOptions();
+void initDebugOptions();
+void initRandomSeedOptions();
+
+} // namespace llvm
 No newline at end of file

llvm/lib/Support/ELFAttributeParser.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace llvm::ELFAttrs;
 
-static const EnumEntry<unsigned> tagNames[] = {
+static constexpr EnumEntry<unsigned> tagNames[] = {
     {"Tag_File", ELFAttrs::File},
     {"Tag_Section", ELFAttrs::Section},
     {"Tag_Symbol", ELFAttrs::Symbol},
 };
 
 Error ELFAttributeParser::parseStringAttribute(const char *name, unsigned tag,
                                                ArrayRef<const char *> strings) {
   uint64_t value = de.getULEB128(cursor);

llvm/lib/Support/GraphWriter.cpp

 //===- GraphWriter.cpp - Implements GraphWriter support routines ----------===//
 //
 // 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 implements misc. GraphWriter support routines.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/GraphWriter.h"
+
+#include "DebugOptions.h"
+
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <system_error>
 #include <string>
 #include <vector>
 
 using namespace llvm;
 
-static cl::opt<bool> ViewBackground("view-background", cl::Hidden,
-  cl::desc("Execute graph viewer in the background. Creates tmp file litter."));
+#ifdef __APPLE__
+namespace {
+struct CreateViewBackground {
+  static void *call() {
+    return new cl::opt<bool>("view-background", cl::Hidden,
+                             cl::desc("Execute graph viewer in the background. "
+                                      "Creates tmp file litter."));
+  }
+};
+} // namespace
+static ManagedStatic<cl::opt<bool>, CreateViewBackground> ViewBackground;
+void llvm::initGraphWriterOptions() { *ViewBackground; }
+#else
+void llvm::initGraphWriterOptions() {}
+#endif
 
 std::string llvm::DOT::EscapeString(const std::string &Label) {
   std::string Str(Label);
   for (unsigned i = 0; i != Str.length(); ++i)
   switch (Str[i]) {
     case '\n':
       Str.insert(Str.begin()+i, '\\');  // Escape character...
       ++i;

llvm/lib/Support/RISCVAttributes.cpp

 //===-- RISCVAttributes.cpp - RISCV Attributes ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/RISCVAttributes.h"
 
 using namespace llvm;
 using namespace llvm::RISCVAttrs;
 
-static const TagNameItem tagData[] = {
+static constexpr TagNameItem tagData[] = {
     {STACK_ALIGN, "Tag_stack_align"},
     {ARCH, "Tag_arch"},
     {UNALIGNED_ACCESS, "Tag_unaligned_access"},
     {PRIV_SPEC, "Tag_priv_spec"},
     {PRIV_SPEC_MINOR, "Tag_priv_spec_minor"},
     {PRIV_SPEC_REVISION, "Tag_priv_spec_revision"},
 };
 
-const TagNameMap llvm::RISCVAttrs::RISCVAttributeTags(tagData,
-                                                      sizeof(tagData) /
-                                                          sizeof(TagNameItem));
+constexpr TagNameMap RISCVAttributeTags{tagData};
+const TagNameMap &llvm::RISCVAttrs::getRISCVAttributeTags() {
+  return RISCVAttributeTags;
+}

llvm/lib/Support/RandomNumberGenerator.cpp

 //===-- RandomNumberGenerator.cpp - Implement RNG class -------------------===//
 //
 // 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 implements deterministic random number generation (RNG).
 // The current implementation is NOT cryptographically secure as it uses
 // the C++11 <random> facilities.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/RandomNumberGenerator.h"
+
+#include "DebugOptions.h"
+
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #ifdef _WIN32
 #include "llvm/Support/Windows/WindowsSupport.h"
 #else
 #include "Unix/Unix.h"
 #endif
 
 using namespace llvm;
 
 #define DEBUG_TYPE "rng"
-
-static cl::opt<uint64_t> Seed("rng-seed", cl::value_desc("seed"), cl::Hidden,
-                              cl::desc("Seed for the random number generator"),
-                              cl::init(0));
+namespace {
+struct CreateSeed {
+  static void *call() {
+    return new cl::opt<uint64_t>(
+        "rng-seed", cl::value_desc("seed"), cl::Hidden,
+        cl::desc("Seed for the random number generator"), cl::init(0));
+  }
+};
+} // namespace
+static ManagedStatic<cl::opt<uint64_t>, CreateSeed> Seed;
+void llvm::initRandomSeedOptions() { *Seed; }
 
 RandomNumberGenerator::RandomNumberGenerator(StringRef Salt) {
-  LLVM_DEBUG(if (Seed == 0) dbgs()
+  LLVM_DEBUG(if (*Seed == 0) dbgs()
              << "Warning! Using unseeded random number generator.\n");
 
   // Combine seed and salts using std::seed_seq.
   // Data: Seed-low, Seed-high, Salt
   // Note: std::seed_seq can only store 32-bit values, even though we
   // are using a 64-bit RNG. This isn't a problem since the Mersenne
   // twister constructor copies these correctly into its initial state.
   std::vector<uint32_t> Data;
   Data.resize(2 + Salt.size());
-  Data[0] = Seed;
-  Data[1] = Seed >> 32;
+  Data[0] = *Seed;
+  Data[1] = *Seed >> 32;
 
   llvm::copy(Salt, Data.begin() + 2);
 
   std::seed_seq SeedSeq(Data.begin(), Data.end());
   Generator.seed(SeedSeq);
 }
 
 RandomNumberGenerator::result_type RandomNumberGenerator::operator()() {

llvm/lib/Support/Signals.cpp

 //===- Signals.cpp - Signal Handling support --------------------*- 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 defines some helpful functions for dealing with the possibility of
 // Unix signals occurring while your program is running.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Signals.h"
+
+#include "DebugOptions.h"
+
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Format.h"

 //=== WARNING: Implementation here must contain only TRULY operating system
 //===          independent code.
 //===----------------------------------------------------------------------===//
 
 using namespace llvm;
 
 // Use explicit storage to avoid accessing cl::opt in a signal handler.
 static bool DisableSymbolicationFlag = false;
-static cl::opt<bool, true>
-    DisableSymbolication("disable-symbolication",
-                         cl::desc("Disable symbolizing crash backtraces."),
-                         cl::location(DisableSymbolicationFlag), cl::Hidden);
-static std::string CrashDiagnosticsDirectory;
-static cl::opt<std::string, true>
-    CrashDiagnosticsDir("crash-diagnostics-dir", cl::value_desc("directory"),
-                        cl::desc("Directory for crash diagnostic files."),
-                        cl::location(CrashDiagnosticsDirectory), cl::Hidden);
+static ManagedStatic<std::string> CrashDiagnosticsDirectory;
+namespace {
+struct CreateDisableSymbolication {
+  static void *call() {
+    return new cl::opt<bool, true>(
+        "disable-symbolication",
+  }
+};
+struct CreateCrashDiagnosticsDir {
+  static void *call() {
+    return new cl::opt<std::string, true>(
+        "crash-diagnostics-dir", cl::value_desc("directory"),
+        cl::location(*CrashDiagnosticsDirectory), cl::Hidden);
+  }
+};
+} // namespace
+void llvm::initSignalsOptions() {
+  static ManagedStatic<cl::opt<bool, true>, CreateDisableSymbolication>
+      DisableSymbolication;
+  static ManagedStatic<cl::opt<std::string, true>, CreateCrashDiagnosticsDir>
+      CrashDiagnosticsDir;
+  *DisableSymbolication;
+  *CrashDiagnosticsDir;
+}
 
 constexpr char DisableSymbolizationEnv[] = "LLVM_DISABLE_SYMBOLIZATION";
 constexpr char LLVMSymbolizerPathEnv[] = "LLVM_SYMBOLIZER_PATH";
 
 // Callbacks to run in signal handler must be lock-free because a signal handler
 // could be running as we add new callbacks. We don't add unbounded numbers of
 // callbacks, an array is therefore sufficient.
 struct CallbackAndCookie {

llvm/lib/Support/Statistic.cpp

 //
 // static Statistic NumInstEliminated("GCSE", "Number of instructions killed");
 //
 // Later, in the code: ++NumInstEliminated;
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Statistic.h"
+
+#include "DebugOptions.h"
+
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
 using namespace llvm;
 
 /// -stats - Command line option to cause transformations to emit stats about
 /// what they did.
 ///
-static cl::opt<bool> EnableStats(
-    "stats",
-    cl::desc("Enable statistics output from program (available with Asserts)"),
-    cl::Hidden);
-
-static cl::opt<bool> StatsAsJSON("stats-json",
-                                 cl::desc("Display statistics as json data"),
-                                 cl::Hidden);
-
+static bool EnableStats;
+static bool StatsAsJSON;
 static bool Enabled;
 static bool PrintOnExit;
 
+void llvm::initStatisticOptions() {
+  static cl::opt<bool, true> registerEnableStats{
+      "stats",
+      cl::desc(
+          "Enable statistics output from program (available with Asserts)"),
+      cl::location(EnableStats), cl::Hidden};
+  static cl::opt<bool, true> registerStatsAsJson{
+      "stats-json", cl::desc("Display statistics as json data"),
+      cl::location(StatsAsJSON), cl::Hidden};
+}
+
 namespace {
 /// This class is used in a ManagedStatic so that it is created on demand (when
 /// the first statistic is bumped) and destroyed only when llvm_shutdown is
 /// called. We print statistics from the destructor.
 /// This class is also used to look up statistic values from applications that
 /// use LLVM.
 class StatisticInfo {
   std::vector<TrackingStatistic *> Stats;
if (EnableStats || PrintOnExit)
     llvm::PrintStatistics();
 }
 
 void llvm::EnableStatistics(bool DoPrintOnExit) {
   Enabled = true;
   PrintOnExit = DoPrintOnExit;
 }
 
-bool llvm::AreStatisticsEnabled() {
-  return Enabled || EnableStats;
-}
+bool llvm::AreStatisticsEnabled() { return Enabled || EnableStats; }
 
 void StatisticInfo::sort() {
   llvm::stable_sort(
       Stats, [](const TrackingStatistic *LHS, const TrackingStatistic *RHS) {
         if (int Cmp = std::strcmp(LHS->getDebugType(), RHS->getDebugType()))
           return Cmp < 0;
 
         if (int Cmp = std::strcmp(LHS->getName(), RHS->getName()))

llvm/lib/Support/TimeProfiler.cpp

 #include <string>
 #include <vector>
 
 using namespace std::chrono;
 using namespace llvm;
 
 static std::mutex Mu;
 // List of all instances
-static std::vector<TimeTraceProfiler *>
+static ManagedStatic<std::vector<TimeTraceProfiler *>>
     ThreadTimeTraceProfilerInstances; // GUARDED_BY(Mu)
 // Per Thread instance
 static LLVM_THREAD_LOCAL TimeTraceProfiler *TimeTraceProfilerInstance = nullptr;
 
 TimeTraceProfiler *llvm::getTimeTraceProfilerInstance() {
   return TimeTraceProfilerInstance;
 }
 
struct llvm::TimeTraceProfiler {
 
   // Write events from this TimeTraceProfilerInstance and
   // ThreadTimeTraceProfilerInstances.
   void write(raw_pwrite_stream &OS) {
     // Acquire Mutex as reading ThreadTimeTraceProfilerInstances.
     std::lock_guard<std::mutex> Lock(Mu);
     assert(Stack.empty() &&
            "All profiler sections should be ended when calling write");
-    assert(llvm::all_of(ThreadTimeTraceProfilerInstances,
+    assert(llvm::all_of(*ThreadTimeTraceProfilerInstances,
                         [](const auto &TTP) { return TTP->Stack.empty(); }) &&
            "All profiler sections should be ended when calling write");
 
     json::OStream J(OS);
     J.objectBegin();
     J.attributeBegin("traceEvents");
     J.arrayBegin();
 
auto writeEvent = [&](const auto &E, uint64_t Tid) {
         J.attribute("name", E.Name);
         if (!E.Detail.empty()) {
           J.attributeObject("args", [&] { J.attribute("detail", E.Detail); });
         }
       });
     };
     for (const Entry &E : Entries)
       writeEvent(E, this->Tid);
-    for (const TimeTraceProfiler *TTP : ThreadTimeTraceProfilerInstances)
+    for (const TimeTraceProfiler *TTP : *ThreadTimeTraceProfilerInstances)
       for (const Entry &E : TTP->Entries)
         writeEvent(E, TTP->Tid);
 
     // Emit totals by section name as additional "thread" events, sorted from
     // longest one.
     // Find highest used thread id.
     uint64_t MaxTid = this->Tid;
-    for (const TimeTraceProfiler *TTP : ThreadTimeTraceProfilerInstances)
+    for (const TimeTraceProfiler *TTP : *ThreadTimeTraceProfilerInstances)
       MaxTid = std::max(MaxTid, TTP->Tid);
 
     // Combine all CountAndTotalPerName from threads into one.
     StringMap<CountAndDurationType> AllCountAndTotalPerName;
     auto combineStat = [&](const auto &Stat) {
       StringRef Key = Stat.getKey();
       auto Value = Stat.getValue();
       auto &CountAndTotal = AllCountAndTotalPerName[Key];
       CountAndTotal.first += Value.first;
       CountAndTotal.second += Value.second;
     };
     for (const auto &Stat : CountAndTotalPerName)
       combineStat(Stat);
-    for (const TimeTraceProfiler *TTP : ThreadTimeTraceProfilerInstances)
+    for (const TimeTraceProfiler *TTP : *ThreadTimeTraceProfilerInstances)
       for (const auto &Stat : TTP->CountAndTotalPerName)
         combineStat(Stat);
 
     std::vector<NameAndCountAndDurationType> SortedTotals;
     SortedTotals.reserve(AllCountAndTotalPerName.size());
     for (const auto &Total : AllCountAndTotalPerName)
       SortedTotals.emplace_back(std::string(Total.getKey()), Total.getValue());
 
auto writeMetadataEvent = [&](const char *Name, uint64_t Tid,
         J.attribute("ph", "M");
         J.attribute("name", Name);
         J.attributeObject("args", [&] { J.attribute("name", arg); });
       });
     };
 
     writeMetadataEvent("process_name", Tid, ProcName);
     writeMetadataEvent("thread_name", Tid, ThreadName);
-    for (const TimeTraceProfiler *TTP : ThreadTimeTraceProfilerInstances)
+    for (const TimeTraceProfiler *TTP : *ThreadTimeTraceProfilerInstances)
       writeMetadataEvent("thread_name", TTP->Tid, TTP->ThreadName);
 
     J.arrayEnd();
     J.attributeEnd();
 
     // Emit the absolute time when this TimeProfiler started.
     // This can be used to combine the profiling data from
     // multiple processes and preserve actual time intervals.
TimeTraceProfilerInstance = new TimeTraceProfiler(
       TimeTraceGranularity, llvm::sys::path::filename(ProcName));
 }
 
 // Removes all TimeTraceProfilerInstances.
 // Called from main thread.
 void llvm::timeTraceProfilerCleanup() {
   delete TimeTraceProfilerInstance;
   std::lock_guard<std::mutex> Lock(Mu);
-  for (auto TTP : ThreadTimeTraceProfilerInstances)
+  for (auto TTP : *ThreadTimeTraceProfilerInstances)
     delete TTP;
-  ThreadTimeTraceProfilerInstances.clear();
+  ThreadTimeTraceProfilerInstances->clear();
 }
 
 // Finish TimeTraceProfilerInstance on a worker thread.
 // This doesn't remove the instance, just moves the pointer to global vector.
 void llvm::timeTraceProfilerFinishThread() {
   std::lock_guard<std::mutex> Lock(Mu);
-  ThreadTimeTraceProfilerInstances.push_back(TimeTraceProfilerInstance);
+  ThreadTimeTraceProfilerInstances->push_back(TimeTraceProfilerInstance);
   TimeTraceProfilerInstance = nullptr;
 }
 
 void llvm::timeTraceProfilerWrite(raw_pwrite_stream &OS) {
   assert(TimeTraceProfilerInstance != nullptr &&
          "Profiler object can't be null");
   TimeTraceProfilerInstance->write(OS);
 }

llvm/lib/Support/Timer.cpp

 //===-- Timer.cpp - Interval Timing Support -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file Interval Timing implementation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Timer.h"
+
+#include "DebugOptions.h"
+
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"

 }
 
 static ManagedStatic<sys::SmartMutex<true> > TimerLock;
 
 /// Allows llvm::Timer to emit signposts when supported.
 static ManagedStatic<SignpostEmitter> Signposts;
 
 namespace {
-  static cl::opt<bool>
-  TrackSpace("track-memory", cl::desc("Enable -time-passes memory "
+struct CreateTrackSpace {
+  static void *call() {
+    return new cl::opt<bool>("track-memory",
+                             cl::desc("Enable -time-passes memory "
                                       "tracking (this may be slow)"),
                              cl::Hidden);
-
-  static cl::opt<std::string, true>
-  InfoOutputFilename("info-output-file", cl::value_desc("filename"),
-                     cl::desc("File to append -stats and -timer output to"),
-                   cl::Hidden, cl::location(getLibSupportInfoOutputFilename()));
-
-  static cl::opt<bool>
-  SortTimers("sort-timers", cl::desc("In the report, sort the timers in each group "
-                                     "in wall clock time order"),
-             cl::init(true), cl::Hidden);
+  }
+};
+static ManagedStatic<cl::opt<bool>, CreateTrackSpace> TrackSpace;
+struct CreateInfoOutputFilename {
+  static void *call() {
+    return new cl::opt<std::string, true>(
+        "info-output-file", cl::value_desc("filename"),
+        cl::desc("File to append -stats and -timer output to"), cl::Hidden,
+        cl::location(getLibSupportInfoOutputFilename()));
+  }
+};
+static ManagedStatic<cl::opt<std::string, true>, CreateInfoOutputFilename>
+    InfoOutputFilename;
+struct CreateSortTimers {
+  static void *call() {
+    return new cl::opt<bool>(
+        "sort-timers",
+        cl::desc("In the report, sort the timers in each group "
   }
+};
+ManagedStatic<cl::opt<bool>, CreateSortTimers> SortTimers;
+} // namespace
+
+void llvm::initTimerOptions() {
+  *TrackSpace;
+  *InfoOutputFilename;
+  *SortTimers;
+}
 
 std::unique_ptr<raw_fd_ostream> llvm::CreateInfoOutputFile() {
   const std::string &OutputFilename = getLibSupportInfoOutputFilename();
   if (OutputFilename.empty())
     return std::make_unique<raw_fd_ostream>(2, false); // stderr.
   if (OutputFilename == "-")
     return std::make_unique<raw_fd_ostream>(1, false); // stdout.
 

 }
 
 Timer::~Timer() {
   if (!TG) return;  // Never initialized, or already cleared.
   TG->removeTimer(*this);
 }
 
 static inline size_t getMemUsage() {
-  if (!TrackSpace) return 0;
+  if (!*TrackSpace)
+    return 0;
   return sys::Process::GetMallocUsage();
 }
 
 static uint64_t getCurInstructionsExecuted() {
 #if defined(HAVE_UNISTD_H) && defined(HAVE_PROC_PID_RUSAGE) &&                 \
     defined(RUSAGE_INFO_V4)
   struct rusage_info_v4 ru;
   if (proc_pid_rusage(getpid(), RUSAGE_INFO_V4, (rusage_info_t *)&ru) == 0) {
if (FirstTimer)
     FirstTimer->Prev = &T.Next;
   T.Next = FirstTimer;
   T.Prev = &FirstTimer;
   FirstTimer = &T;
 }
 
 void TimerGroup::PrintQueuedTimers(raw_ostream &OS) {
   // Perhaps sort the timers in descending order by amount of time taken.
-  if (SortTimers)
+  if (*SortTimers)
     llvm::sort(TimersToPrint);
 
   TimeRecord Total;
   for (const PrintRecord &Record : TimersToPrint)
     Total += Record.Time;
 
   // Print out timing header.
   OS << "===" << std::string(73, '-') << "===\n";

llvm/lib/Support/TypeSize.cpp

 //===- TypeSize.cpp - Wrapper around type sizes------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/TypeSize.h"
 #include "llvm/Support/CommandLine.h"
 
+#include "DebugOptions.h"
+
 using namespace llvm;
 
+#ifndef STRICT_FIXED_SIZE_VECTORS
+namespace {
+struct CreateScalableErrorAsWarning {
   /// The ScalableErrorAsWarning is a temporary measure to suppress errors from
   /// using the wrong interface on a scalable vector.
-cl::opt<bool> ScalableErrorAsWarning(
+  static void *call() {
+    return new cl::opt<bool>(
         "treat-scalable-fixed-error-as-warning", cl::Hidden, cl::init(false),
-    cl::desc("Treat issues where a fixed-width property is requested from a "
-             "scalable type as a warning, instead of an error."),
+        cl::desc(
+            "Treat issues where a fixed-width property is requested from a "
         cl::ZeroOrMore);
+  }
+};
+} // namespace
+static ManagedStatic<cl::opt<bool>, CreateScalableErrorAsWarning>
+    ScalableErrorAsWarning;
+void llvm::initTypeSizeOptions() { *ScalableErrorAsWarning; }
+#else
+void llvm::initTypeSizeOptions() {}
+#endif
 
 void llvm::reportInvalidSizeRequest(const char *Msg) {
 #ifndef STRICT_FIXED_SIZE_VECTORS
-  if (ScalableErrorAsWarning) {
+  if (*ScalableErrorAsWarning) {
     WithColor::warning() << "Invalid size request on a scalable vector; " << Msg
                          << "\n";
     return;
   }
 #endif
   report_fatal_error("Invalid size request on a scalable vector.");
 }
 

llvm/lib/Support/WithColor.cpp

 //===- WithColor.cpp ------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/WithColor.h"
+
+#include "DebugOptions.h"
+
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 
-cl::OptionCategory llvm::ColorCategory("Color Options");
-
-static cl::opt<cl::boolOrDefault>
-    UseColor("color", cl::cat(ColorCategory),
-             cl::desc("Use colors in output (default=autodetect)"),
-             cl::init(cl::BOU_UNSET));
+cl::OptionCategory &llvm::getColorCategory() {
+  static cl::OptionCategory ColorCategory("Color Options");
+  return ColorCategory;
+}
+namespace {
+struct CreateUseColor {
+  static void *call() {
+    return new cl::opt<cl::boolOrDefault>(
+        "color", cl::cat(getColorCategory()),
+  }
+};
+} // namespace
+static ManagedStatic<cl::opt<cl::boolOrDefault>, CreateUseColor> UseColor;
+void llvm::initWithColorOptions() { *UseColor; }
 
 WithColor::WithColor(raw_ostream &OS, HighlightColor Color, ColorMode Mode)
     : OS(OS), Mode(Mode) {
   // Detect color from terminal type unless the user passed the --color option.
   if (colorsEnabled()) {
     switch (Color) {
     case HighlightColor::Address:
       OS.changeColor(raw_ostream::YELLOW);

 
 bool WithColor::colorsEnabled() {
   switch (Mode) {
   case ColorMode::Enable:
     return true;
   case ColorMode::Disable:
     return false;
   case ColorMode::Auto:
-    return UseColor == cl::BOU_UNSET ? OS.has_colors()
-                                     : UseColor == cl::BOU_TRUE;
+    return *UseColor == cl::BOU_UNSET ? OS.has_colors()
+                                      : *UseColor == cl::BOU_TRUE;
   }
   llvm_unreachable("All cases handled above.");
 }
 
 WithColor &WithColor::changeColor(raw_ostream::Colors Color, bool Bold,
                                   bool BG) {
   if (colorsEnabled())
     OS.changeColor(Color, Bold, BG);

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

 ///  ::= .eabi_attribute Tag_name, int [, "str"]
 bool ARMAsmParser::parseDirectiveEabiAttr(SMLoc L) {
   MCAsmParser &Parser = getParser();
   int64_t Tag;
   SMLoc TagLoc;
   TagLoc = Parser.getTok().getLoc();
   if (Parser.getTok().is(AsmToken::Identifier)) {
     StringRef Name = Parser.getTok().getIdentifier();
-    Optional<unsigned> Ret =
-        ELFAttrs::attrTypeFromString(Name, ARMBuildAttrs::ARMAttributeTags);
+    Optional<unsigned> Ret = ELFAttrs::attrTypeFromString(
+        Name, ARMBuildAttrs::getARMAttributeTags());
     if (!Ret.hasValue()) {
       Error(TagLoc, "attribute name not recognised: " + Name);
       return false;
     }
     Tag = Ret.getValue();
     Parser.Lex();
   } else {
     const MCExpr *AttrExpr;

llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

void ARMTargetAsmStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
   OS << "}\n";
 }
 
 void ARMTargetAsmStreamer::switchVendor(StringRef Vendor) {}
 
 void ARMTargetAsmStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
   OS << "\t.eabi_attribute\t" << Attribute << ", " << Twine(Value);
   if (IsVerboseAsm) {
-    StringRef Name =
-        ELFAttrs::attrTypeAsString(Attribute, ARMBuildAttrs::ARMAttributeTags);
+    StringRef Name = ELFAttrs::attrTypeAsString(
+        Attribute, ARMBuildAttrs::getARMAttributeTags());
     if (!Name.empty())
       OS << "\t@ " << Name;
   }
   OS << "\n";
 }
 
 void ARMTargetAsmStreamer::emitTextAttribute(unsigned Attribute,
                                              StringRef String) {
   switch (Attribute) {
   case ARMBuildAttrs::CPU_name:
     OS << "\t.cpu\t" << String.lower();
     break;
   default:
     OS << "\t.eabi_attribute\t" << Attribute << ", \"" << String << "\"";
     if (IsVerboseAsm) {
       StringRef Name = ELFAttrs::attrTypeAsString(
-          Attribute, ARMBuildAttrs::ARMAttributeTags);
+          Attribute, ARMBuildAttrs::getARMAttributeTags());
       if (!Name.empty())
         OS << "\t@ " << Name;
     }
     break;
   }
   OS << "\n";
 }
 
 void ARMTargetAsmStreamer::emitIntTextAttribute(unsigned Attribute,
                                                 unsigned IntValue,
                                                 StringRef StringValue) {
   switch (Attribute) {
   default: llvm_unreachable("unsupported multi-value attribute in asm mode");
   case ARMBuildAttrs::compatibility:
     OS << "\t.eabi_attribute\t" << Attribute << ", " << IntValue;
     if (!StringValue.empty())
       OS << ", \"" << StringValue << "\"";
     if (IsVerboseAsm)
       OS << "\t@ "
          << ELFAttrs::attrTypeAsString(Attribute,
-                                       ARMBuildAttrs::ARMAttributeTags);
+                                       ARMBuildAttrs::getARMAttributeTags());
     break;
   }
   OS << "\n";
 }
 
 void ARMTargetAsmStreamer::emitArch(ARM::ArchKind Arch) {
   OS << "\t.arch\t" << ARM::getArchName(Arch) << "\n";
 }

llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp

 bool RISCVAsmParser::parseDirectiveAttribute() {
   MCAsmParser &Parser = getParser();
   int64_t Tag;
   SMLoc TagLoc;
   TagLoc = Parser.getTok().getLoc();
   if (Parser.getTok().is(AsmToken::Identifier)) {
     StringRef Name = Parser.getTok().getIdentifier();
     Optional<unsigned> Ret =
-        ELFAttrs::attrTypeFromString(Name, RISCVAttrs::RISCVAttributeTags);
+        ELFAttrs::attrTypeFromString(Name, RISCVAttrs::getRISCVAttributeTags());
     if (!Ret.hasValue()) {
       Error(TagLoc, "attribute name not recognised: " + Name);
       return false;
     }
     Tag = Ret.getValue();
     Parser.Lex();
   } else {
     const MCExpr *AttrExpr;

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

int main(int argc, char **argv) {
 
   // Flush outs() when printing to errs(). This avoids interleaving output
   // between the two.
   errs().tie(&outs());
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
 
-  HideUnrelatedOptions({&DwarfDumpCategory, &SectionCategory, &ColorCategory});
+  HideUnrelatedOptions(
+      {&DwarfDumpCategory, &SectionCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(
       argc, argv,
       "pretty-print DWARF debug information in object files"
       " and debug info archives.\n");
 
   // FIXME: Audit interactions between these two options and make them
   //        compatible.
   if (Diff && Verbose) {

llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

std::tie(C.ArchCPUType, C.ArchCPUSubtype) =
             MachO::getArchitectureFromName(ArchType));
   }
 
   return C;
 }
 
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
-  cl::HideUnrelatedOptions({&LibtoolCategory, &ColorCategory});
+  cl::HideUnrelatedOptions({&LibtoolCategory, &getColorCategory()});
   Expected<Config> ConfigOrErr = parseCommandLine(Argc, Argv);
   if (!ConfigOrErr) {
     WithColor::defaultErrorHandler(ConfigOrErr.takeError());
     return EXIT_FAILURE;
   }
 
   if (VersionOption)
     cl::PrintVersionMessage();

llvm/unittests/Support/ARMAttributeParser.cpp

 
 void testParseError(ArrayRef<uint8_t> bytes, const char *msg) {
   ARMAttributeParser parser;
   Error e = parser.parse(bytes, support::little);
   EXPECT_STREQ(toString(std::move(e)).c_str(), msg);
 }
 
 bool testTagString(unsigned Tag, const char *name) {
-  return ELFAttrs::attrTypeAsString(Tag, ARMBuildAttrs::ARMAttributeTags)
+  return ELFAttrs::attrTypeAsString(Tag, ARMBuildAttrs::getARMAttributeTags())
              .str() == name;
 }
 
 TEST(ARMAttributeParser, UnknownCPU_arch) {
   static const uint8_t bytes[] = {'A', 15, 0, 0, 0, 'a', 'e', 'a', 'b',
                                   'i', 0,  1, 7, 0, 0,   0,   6,   22};
   testParseError(bytes, "unknown CPU_arch value: 22");
 }

llvm/unittests/Support/CommandLineTest.cpp

ASSERT_TRUE(Map.count("test-option") == 1) <<
     "Could not find option in map.";
 
   cl::Option *Retrieved = Map["test-option"];
   ASSERT_EQ(&TestOption, Retrieved) << "Retrieved wrong option.";
 
   ASSERT_NE(Retrieved->Categories.end(),
             find_if(Retrieved->Categories,
                     [&](const llvm::cl::OptionCategory *Cat) {
-                      return Cat == &cl::GeneralCategory;
+                      return Cat == &cl::getGeneralCategory();
                     }))
       << "Incorrect default option category.";
 
   Retrieved->addCategory(TestCategory);
   ASSERT_NE(Retrieved->Categories.end(),
             find_if(Retrieved->Categories,
                     [&](const llvm::cl::OptionCategory *Cat) {
                       return Cat == &TestCategory;
ASSERT_NE(TestOption2.Categories.end(),
                          [&](const llvm::cl::OptionCategory *Cat) {
                            return Cat == &TestCategory;
                          }))
       << "Failed to assign Option Category.";
 }
 
 TEST(CommandLineTest, UseMultipleCategories) {
   StackOption<int> TestOption2("test-option2", cl::cat(TestCategory),
-                               cl::cat(cl::GeneralCategory),
-                               cl::cat(cl::GeneralCategory));
+                               cl::cat(cl::getGeneralCategory()),
+                               cl::cat(cl::getGeneralCategory()));
 
-  // Make sure cl::GeneralCategory wasn't added twice.
+  // Make sure cl::getGeneralCategory() wasn't added twice.
   ASSERT_EQ(TestOption2.Categories.size(), 2U);
 
   ASSERT_NE(TestOption2.Categories.end(),
             find_if(TestOption2.Categories,
                          [&](const llvm::cl::OptionCategory *Cat) {
                            return Cat == &TestCategory;
                          }))
       << "Failed to assign Option Category.";
   ASSERT_NE(TestOption2.Categories.end(),
             find_if(TestOption2.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &cl::GeneralCategory;
-                         }))
+                      return Cat == &cl::getGeneralCategory();
       << "Failed to assign General Category.";
 
   cl::OptionCategory AnotherCategory("Additional test Options", "Description");
   StackOption<int> TestOption("test-option", cl::cat(TestCategory),
                               cl::cat(AnotherCategory));
   ASSERT_EQ(TestOption.Categories.end(),
             find_if(TestOption.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &cl::GeneralCategory;
-                         }))
+                      return Cat == &cl::getGeneralCategory();
       << "Failed to remove General Category.";
   ASSERT_NE(TestOption.Categories.end(),
             find_if(TestOption.Categories,
                          [&](const llvm::cl::OptionCategory *Cat) {
                            return Cat == &TestCategory;
                          }))
       << "Failed to assign Option Category.";
   ASSERT_NE(TestOption.Categories.end(),

llvm/unittests/Support/RISCVAttributeParserTest.cpp

static bool testAttribute(unsigned Tag, unsigned Value, unsigned ExpectedTag,
   RISCVAttributeParser Parser;
   cantFail(Parser.parse(Bytes, support::little));
 
   Optional<unsigned> Attr = Parser.getAttributeValue(ExpectedTag);
   return Attr.hasValue() && Attr.getValue() == ExpectedValue;
 }
 
 static bool testTagString(unsigned Tag, const char *name) {
-  return ELFAttrs::attrTypeAsString(Tag, RISCVAttrs::RISCVAttributeTags)
+  return ELFAttrs::attrTypeAsString(Tag, RISCVAttrs::getRISCVAttributeTags())
              .str() == name;
 }
 
 TEST(StackAlign, testAttribute) {
   EXPECT_TRUE(testTagString(4, "Tag_stack_align"));
   EXPECT_TRUE(
       testAttribute(4, 4, RISCVAttrs::STACK_ALIGN, RISCVAttrs::ALIGN_4));
   EXPECT_TRUE(