ManagedStatic: eliminate uses for cl::opt in the llvm directory

[nhaehnle]

Summary

Bring those uses more in line with the pattern used in MLIR, i.e.
pack the cl::opts into a struct. We avoid ManagedStatic entirely by then
instantiating that struct as a static function variable.

Remove additional uses of ManagedStatic in the affected files at the
same time.

[nhaehnle]

Rebase

[efriedma]

llvm/lib/Support/Timer.cpp

47

Is the problem described by this comment not an issue anymore? I guess the timing of the call to initTimerOptions is more predictable since we aren't using a global variable, but is it guaranteed to happen before the StatisticInfo constructor runs?

[nhaehnle]

llvm/lib/Support/Timer.cpp

47

I don't think so, and haven't seen any test issues.

The theoretical justification is: previously, the string was owned by LibSupportInfoOutputFilename, which is seeded from initTimerOptions via getOptions.

With this change, it is owned directly by Options::InfoOutputFilename, which is also seeded from initTimerOptions via getOptions.

Previously, there were multiple globals that had to be coordinated somehow. With the change, everything is owned by a single global.

Now that said, revisiting this I just realized that there is a real change here, which is that if CreateInfoOutputFile is called *without* first calling initTimerOptions, the change will now implicitly create the cl::opts, which was not the case previously.

Is that a problem? Calling CreateInfoOutputFile without first initializing this module seems like a weird thing to do.

[efriedma]

llvm/lib/Support/Timer.cpp

47

The issue would be if the StatisticInfo destructor runs after the string is destroyed. To avoid this, we need to ensure the "Options" struct is constructed before the StatisticInfo constructor returns.

Now that said, revisiting this I just realized that there is a real change here, which is that if CreateInfoOutputFile is called *without* first calling initTimerOptions, the change will now implicitly create the cl::opts, which was not the case previously.

Is that a problem? Calling CreateInfoOutputFile without first initializing this module seems like a weird thing to do.

This doesn't seem likely to cause a problem.

[nhaehnle]

llvm/lib/Support/Timer.cpp

47

Ah, I think I see your point now, but now I'm at the point where I'm doubting whether the unchanged code is really robust.

First off, the comment is wrong: ManagedStatics do get destroyed, when llvm_shutdown is called. So the status quo relies on getLibSupportInfoOutputFilename being called before the StatisticInfo is constructed (or, possibly, being called only when the StatisticInfo is destroyed).

The StatisticInfo constructor does call ConstructTimerLists to address a similar dependency, but that doesn't seem to trigger a call to getLibSupportInfoOutputFilename.

It seems to me that (orthogonal to this change) the StatisticInfo constructor should (indirectly) call getLibSupportInfoOutputFilename. Does that make sense to you? I can draw up a patch for that tomorrow.

[efriedma]

llvm/lib/Support/Timer.cpp

47

Seems fine.

[nhaehnle]

Rebase

llvm/lib/Support/Debug.cpp

 // When compiling without assertions, the -debug-* options and all code in
 // LLVM_DEBUG() statements disappears, so it does not affect the runtime of the
 // code.
 //
 //===----------------------------------------------------------------------===//
 
 #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.
 namespace llvm {
 /// Exported boolean set by the -debug option.
 bool DebugFlag = false;
 
-static ManagedStatic<std::vector<std::string>> CurrentDebugType;
+static std::vector<std::string> &getCurrentDebugType() {
+  static std::vector<std::string> CurrentDebugType;
+  return CurrentDebugType;
+}
 
 /// Return true if the specified string is the debug type
 /// specified on the command line, or if none was specified on the command line
 /// with the -debug-only=X option.
 bool isCurrentDebugType(const char *DebugType) {
-  if (CurrentDebugType->empty())
+  if (getCurrentDebugType().empty())
     return true;
   // See if DebugType is in list. Note: do not use find() as that forces us to
   // unnecessarily create an std::string instance.
-  for (auto &d : *CurrentDebugType) {
+  for (auto &d : getCurrentDebugType()) {
     if (d == DebugType)
       return true;
   }
   return false;
 }
 
 /// Set the current debug type, as if the -debug-only=X
 /// option were specified.  Note that DebugFlag also needs to be set to true for
 /// debug output to be produced.
 ///
 void setCurrentDebugTypes(const char **Types, unsigned Count);
 
 void setCurrentDebugType(const char *Type) {
   setCurrentDebugTypes(&Type, 1);
 }
 
 void setCurrentDebugTypes(const char **Types, unsigned Count) {
-  CurrentDebugType->clear();
+  getCurrentDebugType().clear();
   for (size_t T = 0; T < Count; ++T)
-    CurrentDebugType->push_back(Types[T]);
+    getCurrentDebugType().push_back(Types[T]);
 }
 } // namespace llvm
 
 // All Debug.h functionality is a no-op in NDEBUG mode.
 #ifndef NDEBUG
 
 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.
-struct CreateDebugBufferSize {
-  static void *call() {
-    return new cl::opt<unsigned>(
-        "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));
-  }
-};
-} // 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));
+      getCurrentDebugType().push_back(std::string(dbgType));
   }
 };
-} // namespace
 
-static DebugOnlyOpt DebugOnlyOptLoc;
+struct DebugOptions {
+  // -debug - Command line option to enable the DEBUG statements in the passes.
+  // This flag may only be enabled in debug builds.
+  cl::opt<bool, true> Debug{"debug", cl::desc("Enable debug output"),
+                            cl::Hidden, cl::location(DebugFlag)};
 
-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)"),
-        cl::Hidden, cl::value_desc("debug string"),
-        cl::location(DebugOnlyOptLoc), cl::ValueRequired);
-  }
+  // -debug-buffer-size - Buffer the last N characters of debug output
+  // until program termination.
+  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)};
+
+  cl::opt<DebugOnlyOpt, false, cl::parser<std::string>> DebugOnly{
+      cl::Hidden, cl::value_desc("debug string"), cl::ValueRequired};
 };
-} // namespace
 
-static ManagedStatic<cl::opt<DebugOnlyOpt, true, cl::parser<std::string>>,
-                     CreateDebugOnly>
-    DebugOnly;
-
-void llvm::initDebugOptions() {
-  *Debug;
-  *DebugBufferSize;
-  *DebugOnly;
+DebugOptions &getDebugOptions() {
+  static DebugOptions Opts;
+  return Opts;
 }
 
+} // namespace
+
+void llvm::initDebugOptions() { getDebugOptions(); }
+
 // 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)
+               (!EnableDebugBuffering || !DebugFlag)
+                   ? 0
+                   : getDebugOptions().DebugBufferSize) {
+      if (EnableDebugBuffering && DebugFlag &&
+          getDebugOptions().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/GraphWriter.cpp

 #endif
 
 #include <string>
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 
-#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."));
-  }
+struct Options {
+#ifdef __APPLE__
+  cl::opt<bool> ViewBackground{
+      "view-background", cl::Hidden,
+               "Creates tmp file litter.")};
+#endif
 };
+
+static Options &getOptions() {
+  static Options Opt;
+  return Opt;
+}
 } // namespace
-static ManagedStatic<cl::opt<bool>, CreateViewBackground> ViewBackground;
-void llvm::initGraphWriterOptions() { *ViewBackground; }
-#else
-void llvm::initGraphWriterOptions() {}
-#endif
+
+void llvm::initGraphWriterOptions() { getOptions(); }
 
 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;

 bool llvm::DisplayGraph(StringRef FilenameRef, bool wait,
                         GraphProgram::Name program) {
   std::string Filename = std::string(FilenameRef);
   std::string ErrMsg;
   std::string ViewerPath;
   GraphSession S;
 
 #ifdef __APPLE__
-  wait &= !*ViewBackground;
+  wait &= !getOptions().ViewBackground;
   if (S.TryFindProgram("open", ViewerPath)) {
     std::vector<StringRef> args;
     args.push_back(ViewerPath);
     if (wait)
       args.push_back("-W");
     args.push_back(Filename);
     errs() << "Trying 'open' program... ";
     if (!ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg))

llvm/lib/Support/RandomNumberGenerator.cpp

 #else
 #include "Unix/Unix.h"
 #endif
 
 using namespace llvm;
 
 #define DEBUG_TYPE "rng"
 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));
-  }
+struct Options {
+  cl::opt<uint64_t> Seed{"rng-seed", cl::value_desc("seed"), cl::Hidden,
+                         cl::desc("Seed for the random number generator"),
+                         cl::init(0)};
 };
+
+static Options &getOptions() {
+  static Options Opt;
+  return Opt;
+}
 } // namespace
-static ManagedStatic<cl::opt<uint64_t>, CreateSeed> Seed;
-void llvm::initRandomSeedOptions() { *Seed; }
+
+void llvm::initRandomSeedOptions() { getOptions(); }
 
 RandomNumberGenerator::RandomNumberGenerator(StringRef Salt) {
-  LLVM_DEBUG(if (*Seed == 0) dbgs()
+  auto Seed = getOptions().Seed.getValue();
+  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

 #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"
 #include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
 #include <array>
+#include <atomic>
 #include <vector>
 
 //===----------------------------------------------------------------------===//
 //=== 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 ManagedStatic<std::string> CrashDiagnosticsDirectory;
+static std::string CrashDiagnosticsDirectory;
 namespace {
-struct CreateDisableSymbolication {
-  static void *call() {
-    return new cl::opt<bool, true>(
-        "disable-symbolication",
-        cl::desc("Disable symbolizing crash backtraces."),
-        cl::location(DisableSymbolicationFlag), cl::Hidden);
-  }
-};
-struct CreateCrashDiagnosticsDir {
-  static void *call() {
-    return new cl::opt<std::string, true>(
-        "crash-diagnostics-dir", cl::value_desc("directory"),
-        cl::desc("Directory for crash diagnostic files."),
-        cl::location(*CrashDiagnosticsDirectory), cl::Hidden);
-  }
+struct Options {
+  cl::opt<bool, true> DisableSymbolication{
+      cl::location(DisableSymbolicationFlag), cl::Hidden};
+  cl::opt<std::string, true> CrashDiagnosticsDir{
+      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;
+
+Options &getOptions() {
+  static Options Opt;
+  return Opt;
 }
+} // namespace
+void llvm::initSignalsOptions() { getOptions(); }
 
 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/Timer.cpp

 #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"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signposts.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <limits>
 
 #if HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
 #ifdef HAVE_PROC_PID_RUSAGE
 #include <libproc.h>
 #endif
 
 using namespace llvm;
 
-// This ugly hack is brought to you courtesy of constructor/destructor ordering
-// being unspecified by C++.  Basically the problem is that a Statistic object
-// gets destroyed, which ends up calling 'GetLibSupportInfoOutputFile()'
-// (below), which calls this function.  LibSupportInfoOutputFilename used to be
-// a global variable, but sometimes it would get destroyed before the Statistic,
-// causing havoc to ensue.  We "fix" this by creating the string the first time
-// it is needed and never destroying it.
-static ManagedStatic<std::string> LibSupportInfoOutputFilename;
-static std::string &getLibSupportInfoOutputFilename() {
-  return *LibSupportInfoOutputFilename;
+sys::SmartMutex<true> &getTimerLock() {
+  static sys::SmartMutex<true> TimerLock;
+  return TimerLock;
 }
 
-static ManagedStatic<sys::SmartMutex<true> > TimerLock;
-
 /// Allows llvm::Timer to emit signposts when supported.
-static ManagedStatic<SignpostEmitter> Signposts;
+SignpostEmitter &getSignposts() {
+  static SignpostEmitter Signposts;
+  return Signposts;
+}
 
 namespace {
-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 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 "
-                 "in wall clock time order"),
-        cl::init(true), cl::Hidden);
-  }
+struct Options {
+  cl::opt<bool> TrackSpace{"track-memory",
+                           cl::Hidden};
+  cl::opt<std::string> InfoOutputFilename{
+      cl::desc("File to append -stats and -timer output to"), cl::Hidden};
+  cl::opt<bool> SortTimers{
+      cl::init(true), cl::Hidden};
 };
-ManagedStatic<cl::opt<bool>, CreateSortTimers> SortTimers;
-} // namespace
 
-void llvm::initTimerOptions() {
-  *TrackSpace;
-  *InfoOutputFilename;
-  *SortTimers;
+Options &getOptions() {
+  static Options Opt;
+  return Opt;
 }
+} // namespace
+
+void llvm::initTimerOptions() { (void)getOptions(); }
 
 std::unique_ptr<raw_fd_ostream> llvm::CreateInfoOutputFile() {
-  const std::string &OutputFilename = getLibSupportInfoOutputFilename();
+  const std::string &OutputFilename = getOptions().InfoOutputFilename;
   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.
 
   // Append mode is used because the info output file is opened and closed
   // each time -stats or -time-passes wants to print output to it. To
   // compensate for this, the test-suite Makefiles have code to delete the
   // info output file before running commands which write to it.
   std::error_code EC;
   auto Result = std::make_unique<raw_fd_ostream>(
       OutputFilename, EC, sys::fs::OF_Append | sys::fs::OF_TextWithCRLF);
   if (!EC)
     return Result;
 
   errs() << "Error opening info-output-file '"
     << OutputFilename << " for appending!\n";
   return std::make_unique<raw_fd_ostream>(2, false); // stderr.
 }
 
 namespace {
-struct CreateDefaultTimerGroup {
-  static void *call() {
-    return new TimerGroup("misc", "Miscellaneous Ungrouped Timers");
-  }
+struct DefaultTimerGroup {
+  std::unique_ptr<TimerGroup> Group;
+  DefaultTimerGroup()
+      : Group(new TimerGroup("misc", "Miscellaneous Ungrouped Timers")) {}
 };
 } // namespace
-static ManagedStatic<TimerGroup, CreateDefaultTimerGroup> DefaultTimerGroup;
-static TimerGroup *getDefaultTimerGroup() { return &*DefaultTimerGroup; }
+static std::unique_ptr<TimerGroup> &getDefaultTimerGroup() {
+  static DefaultTimerGroup TheDefaultTimerGroup;
+  return TheDefaultTimerGroup.Group;
+}
 
 //===----------------------------------------------------------------------===//
 // Timer Implementation
 //===----------------------------------------------------------------------===//
 
 void Timer::init(StringRef TimerName, StringRef TimerDescription) {
   init(TimerName, TimerDescription, *getDefaultTimerGroup());
 }

 }
 
 Timer::~Timer() {
   if (!TG) return;  // Never initialized, or already cleared.
   TG->removeTimer(*this);
 }
 
 static inline size_t getMemUsage() {
-  if (!*TrackSpace)
+  if (!getOptions().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;
TimeRecord TimeRecord::getCurrentTime(bool Start) {
   Result.UserTime = Seconds(user).count();
   Result.SystemTime = Seconds(sys).count();
   return Result;
 }
 
 void Timer::startTimer() {
   assert(!Running && "Cannot start a running timer");
   Running = Triggered = true;
-  Signposts->startInterval(this, getName());
+  getSignposts().startInterval(this, getName());
   StartTime = TimeRecord::getCurrentTime(true);
 }
 
 void Timer::stopTimer() {
   assert(Running && "Cannot stop a paused timer");
   Running = false;
   Time += TimeRecord::getCurrentTime(false);
   Time -= StartTime;
-  Signposts->endInterval(this, getName());
+  getSignposts().endInterval(this, getName());
 }
 
 void Timer::clear() {
   Running = Triggered = false;
   Time = StartTime = TimeRecord();
 }
 
 static void printVal(double Val, double Total, raw_ostream &OS) {
public:
   ~Name2PairMap() {
     for (StringMap<std::pair<TimerGroup*, Name2TimerMap> >::iterator
          I = Map.begin(), E = Map.end(); I != E; ++I)
       delete I->second.first;
   }
 
   Timer &get(StringRef Name, StringRef Description, StringRef GroupName,
              StringRef GroupDescription) {
-    sys::SmartScopedLock<true> L(*TimerLock);
+    sys::SmartScopedLock<true> L(getTimerLock());
 
     std::pair<TimerGroup*, Name2TimerMap> &GroupEntry = Map[GroupName];
 
     if (!GroupEntry.first)
       GroupEntry.first = new TimerGroup(GroupName, GroupDescription);
 
     Timer &T = GroupEntry.second[Name];
     if (!T.isInitialized())
       T.init(Name, Description, *GroupEntry.first);
     return T;
   }
 };
 
+Name2PairMap &getNamedGroupedTimers() {
+  static Name2PairMap NamedGroupedTimers;
+  return NamedGroupedTimers;
 }
 
-static ManagedStatic<Name2PairMap> NamedGroupedTimers;
+} // namespace
 
 NamedRegionTimer::NamedRegionTimer(StringRef Name, StringRef Description,
                                    StringRef GroupName,
                                    StringRef GroupDescription, bool Enabled)
     : TimeRegion(!Enabled ? nullptr
-                 : &NamedGroupedTimers->get(Name, Description, GroupName,
+                          : &getNamedGroupedTimers().get(Name, Description,
+                                                         GroupName,
                                                          GroupDescription)) {}
 
 //===----------------------------------------------------------------------===//
 //   TimerGroup Implementation
 //===----------------------------------------------------------------------===//
 
 /// This is the global list of TimerGroups, maintained by the TimerGroup
 /// ctor/dtor and is protected by the TimerLock lock.
 static TimerGroup *TimerGroupList = nullptr;
 
 TimerGroup::TimerGroup(StringRef Name, StringRef Description)
   : Name(Name.begin(), Name.end()),
     Description(Description.begin(), Description.end()) {
   // Add the group to TimerGroupList.
-  sys::SmartScopedLock<true> L(*TimerLock);
+  sys::SmartScopedLock<true> L(getTimerLock());
   if (TimerGroupList)
     TimerGroupList->Prev = &Next;
   Next = TimerGroupList;
   Prev = &TimerGroupList;
   TimerGroupList = this;
 }
 
 TimerGroup::TimerGroup(StringRef Name, StringRef Description,
                        const StringMap<TimeRecord> &Records)
     : TimerGroup(Name, Description) {
   TimersToPrint.reserve(Records.size());
   for (const auto &P : Records)
     TimersToPrint.emplace_back(P.getValue(), std::string(P.getKey()),
                                std::string(P.getKey()));
   assert(TimersToPrint.size() == Records.size() && "Size mismatch");
 }
 
 TimerGroup::~TimerGroup() {
   // If the timer group is destroyed before the timers it owns, accumulate and
   // print the timing data.
   while (FirstTimer)
     removeTimer(*FirstTimer);
 
   // Remove the group from the TimerGroupList.
-  sys::SmartScopedLock<true> L(*TimerLock);
+  sys::SmartScopedLock<true> L(getTimerLock());
   *Prev = Next;
   if (Next)
     Next->Prev = Prev;
 }
 
 
 void TimerGroup::removeTimer(Timer &T) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  sys::SmartScopedLock<true> L(getTimerLock());
 
   // If the timer was started, move its data to TimersToPrint.
   if (T.hasTriggered())
     TimersToPrint.emplace_back(T.Time, T.Name, T.Description);
 
   T.TG = nullptr;
 
   // Unlink the timer from our list.
   *T.Prev = T.Next;
   if (T.Next)
     T.Next->Prev = T.Prev;
 
   // Print the report when all timers in this group are destroyed if some of
   // them were started.
   if (FirstTimer || TimersToPrint.empty())
     return;
 
   std::unique_ptr<raw_ostream> OutStream = CreateInfoOutputFile();
   PrintQueuedTimers(*OutStream);
 }
 
 void TimerGroup::addTimer(Timer &T) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  sys::SmartScopedLock<true> L(getTimerLock());
 
   // Add the timer to our list.
   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 (getOptions().SortTimers)
     llvm::sort(TimersToPrint);
 
   TimeRecord Total;
   for (const PrintRecord &Record : TimersToPrint)
     Total += Record.Time;
 
   // Print out timing header.
   OS << "===" << std::string(73, '-') << "===\n";
   // Figure out how many spaces to indent TimerGroup name.
   unsigned Padding = (80-Description.length())/2;
   if (Padding > 80) Padding = 0;         // Don't allow "negative" numbers
   OS.indent(Padding) << Description << '\n';
   OS << "===" << std::string(73, '-') << "===\n";
 
   // If this is not an collection of ungrouped times, print the total time.
   // Ungrouped timers don't really make sense to add up.  We still print the
   // TOTAL line to make the percentages make sense.
-  if (this != getDefaultTimerGroup())
+  if (this != getDefaultTimerGroup().get())
     OS << format("  Total Execution Time: %5.4f seconds (%5.4f wall clock)\n",
                  Total.getProcessTime(), Total.getWallTime());
   OS << '\n';
 
   if (Total.getUserTime())
     OS << "   ---User Time---";
   if (Total.getSystemTime())
     OS << "   --System Time--";
for (Timer *T = FirstTimer; T; T = T->Next) {
     if (WasRunning)
       T->startTimer();
   }
 }
 
 void TimerGroup::print(raw_ostream &OS, bool ResetAfterPrint) {
   {
     // After preparing the timers we can free the lock
-    sys::SmartScopedLock<true> L(*TimerLock);
+    sys::SmartScopedLock<true> L(getTimerLock());
     prepareToPrintList(ResetAfterPrint);
   }
 
   // If any timers were started, print the group.
   if (!TimersToPrint.empty())
     PrintQueuedTimers(OS);
 }
 
 void TimerGroup::clear() {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  sys::SmartScopedLock<true> L(getTimerLock());
   for (Timer *T = FirstTimer; T; T = T->Next)
     T->clear();
 }
 
 void TimerGroup::printAll(raw_ostream &OS) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  sys::SmartScopedLock<true> L(getTimerLock());
 
   for (TimerGroup *TG = TimerGroupList; TG; TG = TG->Next)
     TG->print(OS);
 }
 
 void TimerGroup::clearAll() {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  sys::SmartScopedLock<true> L(getTimerLock());
   for (TimerGroup *TG = TimerGroupList; TG; TG = TG->Next)
     TG->clear();
 }
 
 void TimerGroup::printJSONValue(raw_ostream &OS, const PrintRecord &R,
                                 const char *suffix, double Value) {
   assert(yaml::needsQuotes(Name) == yaml::QuotingType::None &&
          "TimerGroup name should not need quotes");
   assert(yaml::needsQuotes(R.Name) == yaml::QuotingType::None &&
          "Timer name should not need quotes");
   constexpr auto max_digits10 = std::numeric_limits<double>::max_digits10;
   OS << "\t\"time." << Name << '.' << R.Name << suffix
      << "\": " << format("%.*e", max_digits10 - 1, Value);
 }
 
 const char *TimerGroup::printJSONValues(raw_ostream &OS, const char *delim) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  sys::SmartScopedLock<true> L(getTimerLock());
 
   prepareToPrintList(false);
   for (const PrintRecord &R : TimersToPrint) {
     OS << delim;
     delim = ",\n";
 
     const TimeRecord &T = R.Time;
     printJSONValue(OS, R, ".wall", T.getWallTime());
if (T.getInstructionsExecuted()) {
       printJSONValue(OS, R, ".instr", T.getInstructionsExecuted());
     }
   }
   TimersToPrint.clear();
   return delim;
 }
 
 const char *TimerGroup::printAllJSONValues(raw_ostream &OS, const char *delim) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  sys::SmartScopedLock<true> L(getTimerLock());
   for (TimerGroup *TG = TimerGroupList; TG; TG = TG->Next)
     delim = TG->printJSONValues(OS, delim);
   return delim;
 }
 
 void TimerGroup::ConstructForStatistics() {
-  (void)getLibSupportInfoOutputFilename();
-  (void)*NamedGroupedTimers;
+  (void)getOptions();
+  (void)getNamedGroupedTimers();
 }
 
 std::unique_ptr<TimerGroup> TimerGroup::aquireDefaultGroup() {
-  return std::unique_ptr<TimerGroup>(DefaultTimerGroup.claim());
+  return std::move(getDefaultTimerGroup());
 }

llvm/lib/Support/TypeSize.cpp

 #include "llvm/Support/WithColor.h"
 
 #include "DebugOptions.h"
 
 using namespace llvm;
 
 #ifndef STRICT_FIXED_SIZE_VECTORS
 namespace {
-struct CreateScalableErrorAsWarning {
+struct Options {
   /// The ScalableErrorAsWarning is a temporary measure to suppress errors from
   /// using the wrong interface on a scalable vector.
-  static void *call() {
-    return new cl::opt<bool>(
-        "treat-scalable-fixed-error-as-warning", cl::Hidden,
-        cl::desc(
-            "Treat issues where a fixed-width property is requested from a "
-            "scalable type as a warning, instead of an error"));
-  }
+  cl::opt<bool> ScalableErrorAsWarning{
+      cl::desc("Treat issues where a fixed-width property is requested from a "
+               "scalable type as a warning, instead of an error")};
 };
+
+Options &getOptions() {
+  static Options Opt;
+  return Opt;
+}
 } // namespace
-static ManagedStatic<cl::opt<bool>, CreateScalableErrorAsWarning>
-    ScalableErrorAsWarning;
-void llvm::initTypeSizeOptions() { *ScalableErrorAsWarning; }
+void llvm::initTypeSizeOptions() { (void)getOptions(); }
 #else
 void llvm::initTypeSizeOptions() {}
 #endif
 
 void llvm::reportInvalidSizeRequest(const char *Msg) {
 #ifndef STRICT_FIXED_SIZE_VECTORS
-  if (*ScalableErrorAsWarning) {
+  if (getOptions().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/Unix/Signals.inc

static void insert(std::atomic<FileToRemoveList *> &Head,
     }
   }
 
   // Not signal-safe.
   static void erase(std::atomic<FileToRemoveList *> &Head,
                     const std::string &Filename) {
     // Use a lock to avoid concurrent erase: the comparison would access
     // free'd memory.
-    static ManagedStatic<sys::SmartMutex<true>> Lock;
-    sys::SmartScopedLock<true> Writer(*Lock);
+    static sys::SmartMutex<true> Lock;
+    sys::SmartScopedLock<true> Writer(Lock);
 
     for (FileToRemoveList *Current = Head.load(); Current;
          Current = Current->Next.load()) {
       if (char *OldFilename = Current->Filename.load()) {
         if (OldFilename != Filename)
           continue;
         // Leave an empty filename.
         OldFilename = Current->Filename.exchange(nullptr);

 #else
 static void CreateSigAltStack() {}
 #endif
 
 static void RegisterHandlers() { // Not signal-safe.
   // The mutex prevents other threads from registering handlers while we're
   // doing it. We also have to protect the handlers and their count because
   // a signal handler could fire while we're registeting handlers.
-  static ManagedStatic<sys::SmartMutex<true>> SignalHandlerRegistrationMutex;
-  sys::SmartScopedLock<true> Guard(*SignalHandlerRegistrationMutex);
+  static sys::SmartMutex<true> SignalHandlerRegistrationMutex;
+  sys::SmartScopedLock<true> Guard(SignalHandlerRegistrationMutex);
 
   // If the handlers are already registered, we're done.
   if (NumRegisteredSignals.load() != 0)
     return;
 
   // Create an alternate stack for signal handling. This is necessary for us to
   // be able to reliably handle signals due to stack overflow.
   CreateSigAltStack();
void llvm::sys::DefaultOneShotPipeSignalHandler() {
   // Send a special return code that drivers can check for, from sysexits.h.
   exit(EX_IOERR);
 }
 
 // The public API
 bool llvm::sys::RemoveFileOnSignal(StringRef Filename,
                                    std::string* ErrMsg) {
   // Ensure that cleanup will occur as soon as one file is added.
-  static ManagedStatic<FilesToRemoveCleanup> FilesToRemoveCleanup;
-  *FilesToRemoveCleanup;
+  static FilesToRemoveCleanup FilesToRemoveCleanup;
   FileToRemoveList::insert(FilesToRemove, Filename.str());
   RegisterHandlers();
   return false;
 }
 
 // The public API
 void llvm::sys::DontRemoveFileOnSignal(StringRef Filename) {
   FileToRemoveList::erase(FilesToRemove, Filename.str());

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::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()),
-        cl::desc("Use colors in output (default=autodetect)"),
-        cl::init(cl::BOU_UNSET));
-  }
+struct Options {
+  cl::opt<cl::boolOrDefault> UseColor{
+      cl::init(cl::BOU_UNSET)};
 };
+
+Options &getOptions() {
+  static Options Opt;
+  return Opt;
+}
 } // namespace
-static ManagedStatic<cl::opt<cl::boolOrDefault>, CreateUseColor> UseColor;
-void llvm::initWithColorOptions() { *UseColor; }
+void llvm::initWithColorOptions() { (void)getOptions(); }
 
 static bool DefaultAutoDetectFunction(const raw_ostream &OS) {
-  return *UseColor == cl::BOU_UNSET ? OS.has_colors()
-                                    : *UseColor == cl::BOU_TRUE;
+  cl::boolOrDefault UseColor = getOptions().UseColor;
+  return UseColor == cl::BOU_UNSET ? OS.has_colors() : UseColor == cl::BOU_TRUE;
 }
 
 WithColor::AutoDetectFunctionType WithColor::AutoDetectFunction =
     DefaultAutoDetectFunction;
 
 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.