Switch std::call_once to llvm::call_once

[krytarowski]

Summary

The std::call_once implementation in libstdc++ has problems on few systems: NetBSD, OpenBSD and Linux PPC. LLVM ships with a homegrown implementation llvm::call_once to help on these platforms.

This change is required in the NetBSD LLDB port. std::call_once with libstdc++ results with crashing the debugger.

Sponsored by <The NetBSD Foundation>

[krytarowski]

I can build and test this patch on NetBSD/amd64.

I don't have access right now to a performant FreeBSD, Linux, Android, Windows and FreeBSD hosts to test build and execute tests for this patch on other platforms. Please check.

I was in touch with libstdc++ developers and the reason why std::call_once crashes is still cryptic. A combination of TLS, shared library and pointer to a function passed to pthread_once(3) results in a crash. Switch LLDB to the standard LLVM wrapper for std::cal_once.

Few months back discussed with @mehdi_amini in the context of LLVM.

[mehdi_amini]

I'm fine with this change, but I'll leave the approval to one of the LLDB developer :)

(Thanks for following-up with the libstdc++ on these platforms!)

[clayborg]

Be very careful when using this, you can't change member variables that used to be std::once to be statics. We also don't need the llvm namespace to be included with "using namespace llvm;" in many of the files.

include/lldb/Core/Debugger.h

376

There must be an in ivar for m_clear_once. This can't be a static. Debugger::Clear() can only be called once per debugger instance, not just once ever.

source/Core/Debugger.cpp

68

Why was this added? Remove if not needed.

768–769

This is wrong, it must be in ivar. We are trying to make sure Debugger::Clear() gets calls only once for each instance of a Debugger. Read the comment.

source/Core/ModuleList.cpp

33

Why was this using added? Remove please.

source/Host/common/Editline.cpp

27

Why was this added? Remove if not needed? I hope the LLVM_DEFINE_ONCE_FLAG doesn't require the using directive. If it does, it should be fixed.

source/Host/common/HostInfoBase.cpp

33

Remove

source/Host/linux/HostInfoLinux.cpp

22

Remove

source/Host/windows/HostInfoWindows.cpp

24

Remove

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

38

Remove

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

47

Remove

source/Plugins/Language/Go/GoLanguage.cpp

30

Remove

source/Plugins/Language/Java/JavaLanguage.cpp

32

Remove

source/Plugins/Language/ObjC/ObjCLanguage.cpp

39

Remove

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

51

Remove

source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

51

Remove

source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

53

Remove

source/Plugins/Process/POSIX/ProcessPOSIXLog.cpp

24

Remove

source/Plugins/Process/Windows/Common/ProcessWindows.cpp

44

Remove

source/Plugins/Process/Windows/Common/ProcessWindowsLog.cpp

20

Remove

source/Plugins/Process/elf-core/ProcessElfCore.cpp

40

rm

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

48

rm

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

90

rm

source/Plugins/Process/gdb-remote/ProcessGDBRemoteLog.cpp

24

rm

source/Plugins/Process/mach-core/ProcessMachCore.cpp

50

rm

source/Plugins/Process/minidump/ProcessMinidump.cpp

35

rm

source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

24

rm

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

58

rm

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

91

rm

558–559

You can't change a member variable std::once_flag to a static. Change back

1635

Revert since we shouldn't include llvm namespace.

1641

Revert since we shouldn't include llvm namespace.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

307

You can't remove a member variable once flag. Restore with LLVM version.

source/Symbol/GoASTContext.cpp

34

rm

source/Target/Language.cpp

28

rm

[krytarowski]

In D29288#660636, @clayborg wrote:

Be very careful when using this, you can't change member variables that used to be std::once to be statics. We also don't need the llvm namespace to be included with "using namespace llvm;" in many of the files.

using namespace llvm; is currently required in order to get this functional:

  enum InitStatus { Uninitialized = 0, Wait = 1, Done = 2 };
  typedef volatile sys::cas_flag once_flag;
  /// This macro is the only way you should define your once flag for LLVM's
  /// call_once.
#define LLVM_DEFINE_ONCE_FLAG(flag) static once_flag flag = Uninitialized

sys::cas_flag is a member of the llvm namespace.

[krytarowski]

namespace llvm {
  namespace sys {
    void MemoryFence();

#ifdef _MSC_VER
    typedef long cas_flag;
#else
    typedef uint32_t cas_flag;
#endif
    cas_flag CompareAndSwap(volatile cas_flag* ptr,
                            cas_flag new_value,
                            cas_flag old_value);
  }
}

• include/llvm/Support/Atomic.h of LLVM

[mehdi_amini]

In D29288#660677, @krytarowski wrote:

In D29288#660636, @clayborg wrote:

Be very careful when using this, you can't change member variables that used to be std::once to be statics. We also don't need the llvm namespace to be included with "using namespace llvm;" in many of the files.

using namespace llvm; is currently required in order to get this functional:

What about just updating the macro in LLVM to make it not needed?

#define LLVM_DEFINE_ONCE_FLAG(flag) static llvm::once_flag flag = Uninitialized

[krytarowski]

In D29288#660703, @mehdi_amini wrote:

In D29288#660677, @krytarowski wrote:

In D29288#660636, @clayborg wrote:

Be very careful when using this, you can't change member variables that used to be std::once to be statics. We also don't need the llvm namespace to be included with "using namespace llvm;" in many of the files.

using namespace llvm; is currently required in order to get this functional:

What about just updating the macro in LLVM to make it not needed?

#define LLVM_DEFINE_ONCE_FLAG(flag) static llvm::once_flag flag = Uninitialized

Right, this looks cleaner. I will propose this patch as a separated review.

[krytarowski]

Revamp patch after recent changes in LLVM.

[krytarowski]

Typo.

[krytarowski]

Related https://reviews.llvm.org/D29552

I'm requesting help to test this patch on !NetBSD with and without LLVM_THREADING_USE_STD_CALL_ONCE defined in "llvm/Support/Threading.h". This issue is blocking me from adding functional changes for the NetBSD port.

[labath]

include/lldb/Core/Debugger.h

376–377

The code in llvm says you should only ever use the LLVM_DEFINE_ONCE_FLAG to declare flags. I am guessing it's because it forces the static keyword into the declaration, which in turn guarantees your object will be zero-initialized by the linker. If you declare the flag as a local variable like this, it will be initialized to a random value, and you will have a fun time debugging issues in the future (it will only affect netbsd, as std::call_once platforms will still be correctly initialized).

source/Core/ModuleList.cpp

649–650

This could be simplified to:

static ModuleList *g_shared_module_list = new ModuleList();

It's only written this way because MSVC at one point did not support thread-safe statics.

[krytarowski]

include/lldb/Core/Debugger.h

376–377

I was thinking about it, there is m_clear_once() in lldb/source/Core/Debugger.cpp used in the initializer. But apparently there is no zeroing it with this.

Similar case is in DWARFDataSegment.

struct DWARFDataSegment {
    llvm::once_flag m_flag;
    lldb_private::DWARFDataExtractor m_data;
  };

And another one with static llvm::ManagedStatic<llvm::once_flag> g_once_flag; (I don't fully understand the impact here).

Is there an option to turn llvm::once_flag to behave like std::once_flag? For example changing once_flag to a class like:

class once_flag
{
once_flag() : status(Uninitialized) {};
llvm::sys::cas_flag status;
};

and replace occurrences of flag with flag.status.

Perhaps it would change the code to mechanical replacement of std::once_flag and std::call_ones to llvm:: versions.

[krytarowski]

I've tried to build the LLDB code with mechanically * replaced std::call_once -> llvm::call_once and std::once_flag -> llvm::once_flag:

--- /public/llvm/include/llvm/Support/Threading.h	2017-02-05 00:15:00.769574623 +0100
+++ /usr/pkg/include/llvm/Support/Threading.h	2017-02-05 04:14:03.334251557 +0100
@@ -62,12 +62,16 @@
 
   /// This macro is the only way you should define your once flag for LLVM's
   /// call_once.
-#define LLVM_DEFINE_ONCE_FLAG(flag) static ::llvm::once_flag flag
+#define LLVM_DEFINE_ONCE_FLAG(flag) static once_flag flag
 
 #else
 
   enum InitStatus { Uninitialized = 0, Wait = 1, Done = 2 };
-  typedef volatile sys::cas_flag once_flag;
+  class once_flag {
+  public:
+    once_flag() : status(::llvm::Uninitialized) {};
+    volatile ::llvm::sys::cas_flag status;
+  };
 
   /// This macro is the only way you should define your once flag for LLVM's
   /// call_once.
@@ -96,24 +100,24 @@
 #else
     // For other platforms we use a generic (if brittle) version based on our
     // atomics.
-    sys::cas_flag old_val = sys::CompareAndSwap(&flag, Wait, Uninitialized);
+    sys::cas_flag old_val = sys::CompareAndSwap(&flag.status, Wait, Uninitialized);
     if (old_val == Uninitialized) {
       std::forward<Function>(F)(std::forward<Args>(ArgList)...);
       sys::MemoryFence();
       TsanIgnoreWritesBegin();
-      TsanHappensBefore(&flag);
-      flag = Done;
+      TsanHappensBefore(&flag.status);
+      flag.status = Done;
       TsanIgnoreWritesEnd();
     } else {
       // Wait until any thread doing the call has finished.
-      sys::cas_flag tmp = flag;
+      sys::cas_flag tmp = flag.status;
       sys::MemoryFence();
       while (tmp != Done) {
-        tmp = flag;
+        tmp = flag.status;
         sys::MemoryFence();
       }
     }
-    TsanHappensAfter(&flag);
+    TsanHappensAfter(&flag.status);
 #endif
   }

• there is one exception, I don't understand:

const DWARFDataExtractor &
SymbolFileDWARF::GetCachedSectionData(lldb::SectionType sect_type,
                                      DWARFDataSegment &data_segment) {
#if 0
  llvm::call_once(data_segment.m_flag, &SymbolFileDWARF::LoadSectionData, this,
                 sect_type, std::ref(data_segment.m_data));
#else
  llvm::call_once(data_segment.m_flag,
    [this, sect_type, &data_segment] {
      this->LoadSectionData(sect_type, std::ref(data_segment.m_data));
    }
  );
#endif
  return data_segment.m_data;
}

This exception is valid for so far all versions of switches out of std::once_flag.

[krytarowski]

Test results for the above patch for LLVM and LLDB with "mechanical" switch to llvm::call_once.

===================
Test Result Summary
===================
Test Methods:       1224
Reruns:                1
Success:             268
Expected Failure:     21
Failure:             324
Error:               166
Exceptional Exit:      0
Unexpected Success:    1
Skip:                441
Timeout:               3
Expected Timeout:      0

Results from Jan 21st

===================
Test Result Summary
===================
Test Methods:       1218
Reruns:                1
Success:             264
Expected Failure:     20
Failure:             323
Error:               166
Exceptional Exit:      1
Unexpected Success:    1
Skip:                440
Timeout:               3
Expected Timeout:      0

It looks good to me. The patch on review with LLVM_DEFINE_ONCE_FLAG badly timeouts for me and I interrupted it.

[krytarowski]

Once someone could explain to me why SymbolFileDWARF::GetCachedSectionData cannot be switched mechanically to llvm::call_once, I would like to propose this revamped interface to llvm.

[krytarowski]

https://reviews.llvm.org/D29566 I filed a patch in LLVM.

[krytarowski]

Revamp to new llvm::once_flag

[clayborg]

See inlined comment about initialization when llvm::once_flag is a member variable

include/lldb/Core/Debugger.h

376–377

Is there a valid default initializer for the llvm::once_flag? If so, we are good to go, if not, we need to either initialize it manually, probably by adding another macro to llvm to do the initialization. Static versions might rely on the compiler zeroing out the memory...

[krytarowski]

include/lldb/Core/Debugger.h

376–377

Yes, there is a valid default initializer for llvm::once_flag.

Related entry in LLVM - D29566

[clayborg]

Thanks for doing the right thing in LLVM first, looks great!

include/lldb/Core/Debugger.h

protected:
   lldb::StreamSP m_log_callback_stream_sp;
   ConstString m_instance_name;
   static LoadPluginCallbackType g_load_plugin_callback;
   typedef std::vector<llvm::sys::DynamicLibrary> LoadedPluginsList;
   LoadedPluginsList m_loaded_plugins;
   HostThread m_event_handler_thread;
   HostThread m_io_handler_thread;
   Broadcaster m_sync_broadcaster;
   lldb::ListenerSP m_forward_listener_sp;
-  std::once_flag m_clear_once;
 
   //----------------------------------------------------------------------
   // Events for m_sync_broadcaster
   //----------------------------------------------------------------------
   enum {
     eBroadcastBitEventThreadIsListening = (1 << 0),
   };
 
 private:

source/Commands/CommandObjectPlatform.cpp

 #include "lldb/Interpreter/OptionGroupFile.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Utils.h"
 
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Threading.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 static mode_t ParsePermissionString(const char *) = delete;
 
 static mode_t ParsePermissionString(llvm::StringRef permissions) {
   if (permissions.size() != 9)
     return (mode_t)(-1);
   bool user_r, user_w, user_x, group_r, group_w, group_x, world_r, world_w,
       world_x;
bool DoExecute(Args &args, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
   class CommandOptions : public Options {
   public:
     CommandOptions()
         : Options(), match_info(), show_args(false), verbose(false) {
-      static std::once_flag g_once_flag;
-      std::call_once(g_once_flag, []() {
+      LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+      llvm::call_once(g_once_flag, []() {
         PosixPlatformCommandOptionValidator *posix_validator =
             new PosixPlatformCommandOptionValidator();
         for (auto &Option : g_platform_process_list_options) {
           switch (Option.short_option) {
           case 'u':
           case 'U':
           case 'g':
           case 'G':

source/Core/ConstString.cpp

 #include <array>
 #include <mutex>
 
 // Other libraries and framework includes
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/RWMutex.h"
 
+#include "llvm/Support/Atomic.h"
+
 // Project includes
 #include "lldb/Core/Stream.h"
 
 using namespace lldb_private;
+using namespace llvm;
 
 class Pool {
 public:
   typedef const char *StringPoolValueType;
   typedef llvm::StringMap<StringPoolValueType, llvm::BumpPtrAllocator>
       StringPool;
   typedef llvm::StringMapEntry<StringPoolValueType> StringPoolEntryType;
 

 // function.
 //
 // Note, for now we make the string pool a pointer to the pool, because
 // we can't guarantee that some objects won't get destroyed after the
 // global destructor chain is run, and trying to make sure no destructors
 // touch ConstStrings is difficult.  So we leak the pool instead.
 //----------------------------------------------------------------------
 static Pool &StringPool() {
-  static std::once_flag g_pool_initialization_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_pool_initialization_flag);
   static Pool *g_string_pool = nullptr;
 
-  std::call_once(g_pool_initialization_flag,
+  llvm::call_once(g_pool_initialization_flag,
                  []() { g_string_pool = new Pool(); });
 
   return *g_string_pool;
 }
 
 ConstString::ConstString(const char *cstr)
     : m_string(StringPool().GetConstCString(cstr)) {}
 

source/Core/Debugger.cpp

 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/lldb-private.h"
 
+#include "llvm/Support/Threading.h"
+
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 static lldb::user_id_t g_unique_id = 1;
 static size_t g_debugger_event_thread_stack_bytes = 8 * 1024 * 1024;
 
 #pragma mark Static Functions
 
 typedef std::vector<DebuggerSP> DebuggerList;
 static std::recursive_mutex *g_debugger_list_mutex_ptr =
: UserID(g_unique_id++),
       m_terminal_state(), m_target_list(*this), m_platform_list(),
       m_listener_sp(Listener::MakeListener("lldb.Debugger")),
       m_source_manager_ap(), m_source_file_cache(),
       m_command_interpreter_ap(
           new CommandInterpreter(*this, eScriptLanguageDefault, false)),
       m_input_reader_stack(), m_instance_name(), m_loaded_plugins(),
       m_event_handler_thread(), m_io_handler_thread(),
       m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
-      m_forward_listener_sp(), m_clear_once() {
+      m_forward_listener_sp() {
   char instance_cstr[256];
   snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID());
   m_instance_name.SetCString(instance_cstr);
   if (log_callback)
     m_log_callback_stream_sp.reset(new StreamCallback(log_callback, baton));
   m_command_interpreter_ap->Initialize();
   // Always add our default platform to the platform list
   PlatformSP default_platform_sp(Platform::GetHostPlatform());
void Debugger::Clear() {
   // running on other threads, we need to ensure this doesn't happen
   // multiple times.
   //
   // The following functions call Debugger::Clear():
   //     Debugger::~Debugger();
   //     static void Debugger::Destroy(lldb::DebuggerSP &debugger_sp);
   //     static void Debugger::Terminate();
   //----------------------------------------------------------------------
-  std::call_once(m_clear_once, [this]() {
+  LLVM_DEFINE_ONCE_FLAG(m_clear_once);
+  llvm::call_once(m_clear_once, [this]() {
     ClearIOHandlers();
     StopIOHandlerThread();
     StopEventHandlerThread();
     m_listener_sp->Clear();
     int num_targets = m_target_list.GetNumTargets();
     for (int i = 0; i < num_targets; i++) {
       TargetSP target_sp(m_target_list.GetTargetAtIndex(i));
       if (target_sp) {

source/Core/ModuleList.cpp

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VariableList.h"
 
+#include "llvm/Support/Threading.h"
+
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 ModuleList::ModuleList()
     : m_modules(), m_modules_mutex(), m_notifier(nullptr) {}
 
 ModuleList::ModuleList(const ModuleList &rhs)
     : m_modules(), m_modules_mutex(), m_notifier(nullptr) {
   std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
   std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
for (pos = begin; pos != end; ++pos) {
       if ((*pos).get() == module)
         return std::distance(begin, pos);
     }
   }
   return LLDB_INVALID_INDEX32;
 }
 
 static ModuleList &GetSharedModuleList() {
   static ModuleList *g_shared_module_list = nullptr;
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
     // NOTE: Intentionally leak the module list so a program doesn't have to
     // cleanup all modules and object files as it exits. This just wastes time
     // doing a bunch of cleanup that isn't required.
     if (g_shared_module_list == nullptr)
       g_shared_module_list = new ModuleList(); // <--- Intentional leak!!!
   });
   return *g_shared_module_list;
 }

source/Host/common/Editline.cpp

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/SelectHelper.h"
 
 using namespace lldb_private;
 using namespace lldb_private::line_editor;
+using namespace llvm;
 
 // Workaround for what looks like an OS X-specific issue, but other platforms
 // may benefit from something similar if issues arise.  The libedit library
 // doesn't explicitly initialize the curses termcap library, which it gets away
 // with until TERM is set to VT100 where it stumbles over an implementation
 // assumption that may not exist on other platforms.  The setupterm() function
 // would normally require headers that don't work gracefully in this context, so
 // the function declaraction has been hoisted here.
Editline::Editline(const char *editline_name, FILE *input_file,
   m_history_sp = EditlineHistory::GetHistory(m_editor_name);
 
 #ifdef USE_SETUPTERM_WORKAROUND
   if (m_output_file) {
     const int term_fd = fileno(m_output_file);
     if (term_fd != -1) {
       static std::mutex *g_init_terminal_fds_mutex_ptr = nullptr;
       static std::set<int> *g_init_terminal_fds_ptr = nullptr;
-      static std::once_flag g_once_flag;
-      std::call_once(g_once_flag, [&]() {
+      LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+      llvm::call_once(g_once_flag, [&]() {
         g_init_terminal_fds_mutex_ptr =
             new std::mutex(); // NOTE: Leak to avoid C++ destructor chain issues
         g_init_terminal_fds_ptr = new std::set<int>(); // NOTE: Leak to avoid
                                                        // C++ destructor chain
                                                        // issues
       });
 
       // We must make sure to initialize the terminal a given file descriptor

source/Host/common/HostInfoBase.cpp

 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostInfoBase.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <mutex> // std::once
 #include <thread>
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 namespace {
 //----------------------------------------------------------------------
 // The HostInfoBaseFields is a work around for windows not supporting
 // static variables correctly in a thread safe way. Really each of the
 // variables in HostInfoBaseFields should live in the functions in which
 // they are used and each one should be static, but the work around is
 // in place to avoid this restriction. Ick.

 void HostInfoBase::Initialize() { g_fields = new HostInfoBaseFields(); }
 
 void HostInfoBase::Terminate() {
   delete g_fields;
   g_fields = nullptr;
 }
 
 uint32_t HostInfoBase::GetNumberCPUS() {
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
     g_fields->m_number_cpus = std::thread::hardware_concurrency();
   });
   return g_fields->m_number_cpus;
 }
 
 uint32_t HostInfoBase::GetMaxThreadNameLength() { return 0; }
 
 llvm::StringRef HostInfoBase::GetVendorString() {
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
     g_fields->m_vendor_string =
         HostInfo::GetArchitecture().GetTriple().getVendorName().str();
   });
   return g_fields->m_vendor_string;
 }
 
 llvm::StringRef HostInfoBase::GetOSString() {
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
     g_fields->m_os_string =
         std::move(HostInfo::GetArchitecture().GetTriple().getOSName());
   });
   return g_fields->m_os_string;
 }
 
 llvm::StringRef HostInfoBase::GetTargetTriple() {
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
     g_fields->m_host_triple =
         HostInfo::GetArchitecture().GetTriple().getTriple();
   });
   return g_fields->m_host_triple;
 }
 
 const ArchSpec &HostInfoBase::GetArchitecture(ArchitectureKind arch_kind) {
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
     HostInfo::ComputeHostArchitectureSupport(g_fields->m_host_arch_32,
                                              g_fields->m_host_arch_64);
   });
 
   // If an explicit 32 or 64-bit architecture was requested, return that.
   if (arch_kind == eArchKind32)
     return g_fields->m_host_arch_32;
   if (arch_kind == eArchKind64)

 #if defined(LLDB_DISABLE_PYTHON)
   if (type == lldb::ePathTypePythonDir)
     return false;
 #endif
 
   FileSpec *result = nullptr;
   switch (type) {
   case lldb::ePathTypeLLDBShlibDir: {
-    static std::once_flag g_once_flag;
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
     static bool success = false;
-    std::call_once(g_once_flag, []() {
+    llvm::call_once(g_once_flag, []() {
       success =
           HostInfo::ComputeSharedLibraryDirectory(g_fields->m_lldb_so_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf("HostInfoBase::GetLLDBPath(ePathTypeLLDBShlibDir) => '%s'",
                     g_fields->m_lldb_so_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_so_dir;
   } break;
   case lldb::ePathTypeSupportExecutableDir: {
-    static std::once_flag g_once_flag;
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
     static bool success = false;
-    std::call_once(g_once_flag, []() {
+    llvm::call_once(g_once_flag, []() {
       success = HostInfo::ComputeSupportExeDirectory(
           g_fields->m_lldb_support_exe_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf(
             "HostInfoBase::GetLLDBPath(ePathTypeSupportExecutableDir) => '%s'",
             g_fields->m_lldb_support_exe_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_support_exe_dir;
   } break;
   case lldb::ePathTypeHeaderDir: {
-    static std::once_flag g_once_flag;
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
     static bool success = false;
-    std::call_once(g_once_flag, []() {
+    llvm::call_once(g_once_flag, []() {
       success = HostInfo::ComputeHeaderDirectory(g_fields->m_lldb_headers_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf("HostInfoBase::GetLLDBPath(ePathTypeHeaderDir) => '%s'",
                     g_fields->m_lldb_headers_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_headers_dir;
   } break;
   case lldb::ePathTypePythonDir: {
-    static std::once_flag g_once_flag;
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
     static bool success = false;
-    std::call_once(g_once_flag, []() {
+    llvm::call_once(g_once_flag, []() {
       success = HostInfo::ComputePythonDirectory(g_fields->m_lldb_python_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf("HostInfoBase::GetLLDBPath(ePathTypePythonDir) => '%s'",
                     g_fields->m_lldb_python_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_python_dir;
   } break;
   case lldb::ePathTypeClangDir: {
-    static std::once_flag g_once_flag;
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
     static bool success = false;
-    std::call_once(g_once_flag, []() {
+    llvm::call_once(g_once_flag, []() {
       success =
           HostInfo::ComputeClangDirectory(g_fields->m_lldb_clang_resource_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf(
             "HostInfoBase::GetLLDBPath(ePathTypeClangResourceDir) => '%s'",
             g_fields->m_lldb_clang_resource_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_clang_resource_dir;
   } break;
   case lldb::ePathTypeLLDBSystemPlugins: {
-    static std::once_flag g_once_flag;
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
     static bool success = false;
-    std::call_once(g_once_flag, []() {
+    llvm::call_once(g_once_flag, []() {
       success = HostInfo::ComputeSystemPluginsDirectory(
           g_fields->m_lldb_system_plugin_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf(
             "HostInfoBase::GetLLDBPath(ePathTypeLLDBSystemPlugins) => '%s'",
             g_fields->m_lldb_system_plugin_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_system_plugin_dir;
   } break;
   case lldb::ePathTypeLLDBUserPlugins: {
-    static std::once_flag g_once_flag;
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
     static bool success = false;
-    std::call_once(g_once_flag, []() {
+    llvm::call_once(g_once_flag, []() {
       success = HostInfo::ComputeUserPluginsDirectory(
           g_fields->m_lldb_user_plugin_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf(
             "HostInfoBase::GetLLDBPath(ePathTypeLLDBUserPlugins) => '%s'",
             g_fields->m_lldb_user_plugin_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_user_plugin_dir;
   } break;
   case lldb::ePathTypeLLDBTempSystemDir: {
-    static std::once_flag g_once_flag;
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
     static bool success = false;
-    std::call_once(g_once_flag, []() {
+    llvm::call_once(g_once_flag, []() {
       success = HostInfo::ComputeProcessTempFileDirectory(
           g_fields->m_lldb_process_tmp_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf(
             "HostInfoBase::GetLLDBPath(ePathTypeLLDBTempSystemDir) => '%s'",
             g_fields->m_lldb_process_tmp_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_process_tmp_dir;
   } break;
   case lldb::ePathTypeGlobalLLDBTempSystemDir: {
-    static std::once_flag g_once_flag;
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
     static bool success = false;
-    std::call_once(g_once_flag, []() {
+    llvm::call_once(g_once_flag, []() {
       success = HostInfo::ComputeGlobalTempFileDirectory(
           g_fields->m_lldb_global_tmp_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf("HostInfoBase::GetLLDBPath("
                     "ePathTypeGlobalLLDBTempSystemDir) => '%s'",
                     g_fields->m_lldb_global_tmp_dir.GetPath().c_str());
     });

source/Host/linux/HostInfoLinux.cpp

 #include <stdio.h>
 #include <string.h>
 #include <sys/utsname.h>
 
 #include <algorithm>
 #include <mutex> // std::once
 
 using namespace lldb_private;
+using namespace llvm;
 
 namespace {
 struct HostInfoLinuxFields {
   HostInfoLinuxFields() : m_os_major(0), m_os_minor(0), m_os_update(0) {}
 
   std::string m_distribution_id;
   uint32_t m_os_major;
   uint32_t m_os_minor;
void HostInfoLinux::Initialize() {
   g_fields = new HostInfoLinuxFields();
 }
 
 uint32_t HostInfoLinux::GetMaxThreadNameLength() { return 16; }
 
 bool HostInfoLinux::GetOSVersion(uint32_t &major, uint32_t &minor,
                                  uint32_t &update) {
   static bool success = false;
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
 
     struct utsname un;
     if (uname(&un) == 0) {
       int status = sscanf(un.release, "%u.%u.%u", &g_fields->m_os_major,
                           &g_fields->m_os_minor, &g_fields->m_os_update);
       if (status == 3)
         success = true;
       else {
bool HostInfoLinux::GetOSKernelDescription(std::string &s) {
 
   s.assign(un.version);
   return true;
 }
 
 llvm::StringRef HostInfoLinux::GetDistributionId() {
   // Try to run 'lbs_release -i', and use that response
   // for the distribution id.
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST));
     if (log)
       log->Printf("attempting to determine Linux distribution...");
 
     // check if the lsb_release command exists at one of the
     // following paths
     const char *const exe_paths[] = {"/bin/lsb_release",

source/Host/windows/HostInfoWindows.cpp

 #include "lldb/Host/windows/HostInfoWindows.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace lldb_private;
+using namespace llvm;
 
 FileSpec HostInfoWindows::m_program_filespec;
 
 void HostInfoWindows::Initialize() {
   ::CoInitializeEx(nullptr, COINIT_MULTITHREADED);
   HostInfoBase::Initialize();
 }
 
bool HostInfoWindows::GetHostname(std::string &s) {
   DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
   if (!::GetComputerNameW(buffer, &dwSize))
     return false;
 
   return llvm::convertWideToUTF8(buffer, s);
 }
 
 FileSpec HostInfoWindows::GetProgramFileSpec() {
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
     std::vector<wchar_t> buffer(PATH_MAX);
     ::GetModuleFileNameW(NULL, buffer.data(), buffer.size());
     std::string path;
     llvm::convertWideToUTF8(buffer.data(), path);
     m_program_filespec.SetFile(path, false);
   });
   return m_program_filespec;
 }

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBAssert.h"
 
 using namespace lldb_private;
+using namespace llvm;
 
 namespace {
 // Any Clang compiler requires a consumer for diagnostics.  This one stores them
 // as strings
 // so we can provide them to the user in case a module failed to load.
 class StoringDiagnosticConsumer : public clang::DiagnosticConsumer {
 public:
   StoringDiagnosticConsumer();
case clang::DiagnosticsEngine::Level::Ignored:
       break;
     }
   }
 }
 
 static FileSpec GetResourceDir() {
   static FileSpec g_cached_resource_dir;
 
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     HostInfo::GetLLDBPath(lldb::ePathTypeClangDir, g_cached_resource_dir);
   });
 
   return g_cached_resource_dir;
 }
 
 ClangModulesDeclVendor::ClangModulesDeclVendor() {}
 

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

 #include "lldb/Core/Log.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/DataFormatters/CXXFunctionPointer.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/VectorType.h"
+#include "llvm/Support/Threading.h"
 
 #include "BlockPointer.h"
 #include "CxxStringTypes.h"
 #include "LibCxx.h"
 #include "LibCxxAtomic.h"
 #include "LibStdcpp.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
+using namespace llvm;
 
 void CPlusPlusLanguage::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language",
                                 CreateInstance);
 }
 
 void CPlusPlusLanguage::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
virtual CompilerType AdjustForInclusion(CompilerType &candidate) override {
       return candidate;
     }
   };
 
   return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger());
 }
 
 lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() {
-  static std::once_flag g_initialize;
+  LLVM_DEFINE_ONCE_FLAG(g_initialize);
   static TypeCategoryImplSP g_category;
 
-  std::call_once(g_initialize, [this]() -> void {
+  llvm::call_once(g_initialize, [this]() -> void {
     DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
     if (g_category) {
       LoadLibCxxFormatters(g_category);
       LoadLibStdcppFormatters(g_category);
       LoadSystemFormatters(g_category);
     }
   });
   return g_category;
 }
 
 HardcodedFormatters::HardcodedSummaryFinder
 CPlusPlusLanguage::GetHardcodedSummaries() {
-  static std::once_flag g_initialize;
+  LLVM_DEFINE_ONCE_FLAG(g_initialize);
   static ConstString g_vectortypes("VectorTypes");
   static HardcodedFormatters::HardcodedSummaryFinder g_formatters;
 
-  std::call_once(g_initialize, []() -> void {
+  llvm::call_once(g_initialize, []() -> void {
     g_formatters.push_back(
         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
            FormatManager &) -> TypeSummaryImpl::SharedPointer {
           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
               new CXXFunctionSummaryFormat(
                   TypeSummaryImpl::Flags(),
                   lldb_private::formatters::CXXFunctionPointerSummaryProvider,
                   "Function pointer summary provider"));
g_formatters.push_back(
         });
   });
 
   return g_formatters;
 }
 
 HardcodedFormatters::HardcodedSyntheticFinder
 CPlusPlusLanguage::GetHardcodedSynthetics() {
-  static std::once_flag g_initialize;
+  LLVM_DEFINE_ONCE_FLAG(g_initialize);
   static ConstString g_vectortypes("VectorTypes");
   static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;
 
-  std::call_once(g_initialize, []() -> void {
+  llvm::call_once(g_initialize, []() -> void {
     g_formatters.push_back([](lldb_private::ValueObject &valobj,
                               lldb::DynamicValueType,
                               FormatManager &
                                   fmt_mgr) -> SyntheticChildren::SharedPointer {
       static CXXSyntheticChildren::SharedPointer formatter_sp(
           new CXXSyntheticChildren(
               SyntheticChildren::Flags()
                   .SetCascades(true)

source/Plugins/Language/Go/GoLanguage.cpp

 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/GoASTContext.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
+using namespace llvm;
 
 void GoLanguage::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), "Go Language",
                                 CreateInstance);
 }
 
 void GoLanguage::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);

 Language *GoLanguage::CreateInstance(lldb::LanguageType language) {
   if (language == eLanguageTypeGo)
     return new GoLanguage();
   return nullptr;
 }
 
 HardcodedFormatters::HardcodedSummaryFinder
 GoLanguage::GetHardcodedSummaries() {
-  static std::once_flag g_initialize;
+  LLVM_DEFINE_ONCE_FLAG(g_initialize);
   static HardcodedFormatters::HardcodedSummaryFinder g_formatters;
 
-  std::call_once(g_initialize, []() -> void {
+  llvm::call_once(g_initialize, []() -> void {
     g_formatters.push_back(
         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
            FormatManager &) -> TypeSummaryImpl::SharedPointer {
           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
               new CXXFunctionSummaryFormat(
                   TypeSummaryImpl::Flags().SetDontShowChildren(true),
                   lldb_private::formatters::GoStringSummaryProvider,
                   "Go string summary provider"));
g_formatters.push_back(
           return nullptr;
         });
   });
   return g_formatters;
 }
 
 HardcodedFormatters::HardcodedSyntheticFinder
 GoLanguage::GetHardcodedSynthetics() {
-  static std::once_flag g_initialize;
+  LLVM_DEFINE_ONCE_FLAG(g_initialize);
   static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;
 
-  std::call_once(g_initialize, []() -> void {
+  llvm::call_once(g_initialize, []() -> void {
     g_formatters.push_back(
         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
            FormatManager &fmt_mgr) -> SyntheticChildren::SharedPointer {
           static CXXSyntheticChildren::SharedPointer formatter_sp(
               new CXXSyntheticChildren(
                   SyntheticChildren::Flags(), "slice synthetic children",
                   lldb_private::formatters::GoSliceSyntheticFrontEndCreator));
           if (GoASTContext::IsGoSlice(valobj.GetCompilerType())) {
             return formatter_sp;
           }
           return nullptr;
         });
   });
 
   return g_formatters;
 }

source/Plugins/Language/Java/JavaLanguage.cpp

 // C Includes
 #include <string.h>
 // C++ Includes
 #include <functional>
 #include <mutex>
 
 // Other libraries and framework includes
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Threading.h"
 
 // Project includes
 #include "JavaFormatterFunctions.h"
 #include "JavaLanguage.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/JavaASTContext.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
+using namespace llvm;
 
 void JavaLanguage::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), "Java Language",
                                 CreateInstance);
 }
 
 void JavaLanguage::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
bool JavaLanguage::IsNilReference(ValueObject &valobj) {
   if (!valobj.GetCompilerType().IsReferenceType())
     return false;
 
   // If we failed to read the value then it is not a nil reference.
   return valobj.GetValueAsUnsigned(UINT64_MAX) == 0;
 }
 
 lldb::TypeCategoryImplSP JavaLanguage::GetFormatters() {
-  static std::once_flag g_initialize;
+  LLVM_DEFINE_ONCE_FLAG(g_initialize);
   static TypeCategoryImplSP g_category;
 
-  std::call_once(g_initialize, [this]() -> void {
+  llvm::call_once(g_initialize, [this]() -> void {
     DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
     if (g_category) {
       llvm::StringRef array_regexp("^.*\\[\\]&?$");
 
       lldb::TypeSummaryImplSP string_summary_sp(new CXXFunctionSummaryFormat(
           TypeSummaryImpl::Flags().SetDontShowChildren(true),
           lldb_private::formatters::JavaStringSummaryProvider,
           "java.lang.String summary provider"));

source/Plugins/Language/ObjC/ObjCLanguage.cpp

 #include "CoreMedia.h"
 #include "NSDictionary.h"
 #include "NSSet.h"
 #include "NSString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
+using namespace llvm;
 
 void ObjCLanguage::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), "Objective-C Language",
                                 CreateInstance);
 }
 
 void ObjCLanguage::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);

 #ifndef LLDB_DISABLE_PYTHON
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::CMTimeSummaryProvider,
                 "CMTime summary provider", ConstString("CMTime"), cm_flags);
 #endif // LLDB_DISABLE_PYTHON
 }
 
 lldb::TypeCategoryImplSP ObjCLanguage::GetFormatters() {
-  static std::once_flag g_initialize;
+  LLVM_DEFINE_ONCE_FLAG(g_initialize);
   static TypeCategoryImplSP g_category;
 
-  std::call_once(g_initialize, [this]() -> void {
+  llvm::call_once(g_initialize, [this]() -> void {
     DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
     if (g_category) {
       LoadCoreMediaFormatters(g_category);
       LoadObjCFormatters(g_category);
     }
   });
   return g_category;
 }

source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp

#if defined(__APPLE__)
   return m_core_simulator_framework_path.getValue();
 #else
   return FileSpec();
 #endif
 }
 
 void PlatformAppleSimulator::LoadCoreSimulator() {
 #if defined(__APPLE__)
-  static std::once_flag g_load_core_sim_flag;
-  std::call_once(g_load_core_sim_flag, [this] {
+  LLVM_DEFINE_ONCE_FLAG(g_load_core_sim_flag);
+  llvm::call_once(g_load_core_sim_flag, [this] {
     const std::string core_sim_path(GetCoreSimulatorPath().GetPath());
     if (core_sim_path.size())
       dlopen(core_sim_path.c_str(), RTLD_LAZY);
   });
 #endif
 }
 
 #if defined(__APPLE__)

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Threading.h"
 
 #if defined(__APPLE__)
 #include <TargetConditionals.h> // for TARGET_OS_TV, TARGET_OS_WATCH
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformDarwin::PlatformDarwin(bool is_host)
     : PlatformPOSIX(is_host), // This is the local host platform
       m_developer_directory() {}
 
if (pos != std::string::npos) {
       }
     }
   }
   return FileSpec();
 }
 
 static FileSpec GetXcodeContentsPath() {
   static FileSpec g_xcode_filespec;
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
 
     FileSpec fspec;
 
     // First get the program file spec. If lldb.so or LLDB.framework is running
     // in a program and that program is Xcode, the path returned with be the
     // path
     // to Xcode.app/Contents/MacOS/Xcode, so this will be the correct Xcode to
     // use.

 lldb_private::FileSpec PlatformDarwin::LocateExecutable(const char *basename) {
   // A collection of SBFileSpec whose SBFileSpec.m_directory members are filled
   // in with
   // any executable directories that should be searched.
   static std::vector<FileSpec> g_executable_dirs;
 
   // Find the global list of directories that we will search for
   // executables once so we don't keep doing the work over and over.
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
 
     // When locating executables, trust the DEVELOPER_DIR first if it is set
     FileSpec xcode_contents_dir = GetXcodeContentsPath();
     if (xcode_contents_dir) {
       FileSpec xcode_lldb_resources = xcode_contents_dir;
       xcode_lldb_resources.AppendPathComponent("SharedFrameworks");
       xcode_lldb_resources.AppendPathComponent("LLDB.framework");
       xcode_lldb_resources.AppendPathComponent("Resources");

source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 
 #include "lldb/Host/posix/Fcntl.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 namespace {
 UnixSignalsSP &GetFreeBSDSignals() {
   static UnixSignalsSP s_freebsd_signals_sp(new FreeBSDSignals());
   return s_freebsd_signals_sp;
 }
 }
 
 //------------------------------------------------------------------------------
 // Static functions.
 
 lldb::ProcessSP
 ProcessFreeBSD::CreateInstance(lldb::TargetSP target_sp,
                                lldb::ListenerSP listener_sp,
                                const FileSpec *crash_file_path) {
   lldb::ProcessSP process_sp;
   if (crash_file_path == NULL)
     process_sp.reset(
         new ProcessFreeBSD(target_sp, listener_sp, GetFreeBSDSignals()));
   return process_sp;
 }
 
 void ProcessFreeBSD::Initialize() {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(), CreateInstance);
     ProcessPOSIXLog::Initialize(GetPluginNameStatic());
   });
 }
 
 lldb_private::ConstString ProcessFreeBSD::GetPluginNameStatic() {
   static ConstString g_name("freebsd");

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 using namespace llvm;
 
 // Private bits we only need internally.
 
 static bool ProcessVmReadvSupported() {
   static bool is_supported;
-  static std::once_flag flag;
+  LLVM_DEFINE_ONCE_FLAG(flag);
 
-  std::call_once(flag, [] {
+  llvm::call_once(flag, [] {
     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
     uint32_t source = 0x47424742;
     uint32_t dest = 0;
 
     struct iovec local, remote;
     remote.iov_base = &source;
     local.iov_base = &dest;

source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 #include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
 #include "ProcessKDP.h"
 #include "ProcessKDPLog.h"
 #include "ThreadKDP.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 namespace {
 
 static PropertyDefinition g_properties[] = {
     {"packet-timeout", OptionValue::eTypeUInt64, true, 5, NULL, NULL,
      "Specify the default packet timeout in seconds."},
     {NULL, OptionValue::eTypeInvalid, false, 0, NULL, NULL, NULL}};
 

 Error ProcessKDP::DoSignal(int signo) {
   Error error;
   error.SetErrorString(
       "sending signals is not suppported in kdp remote debugging");
   return error;
 }
 
 void ProcessKDP::Initialize() {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(), CreateInstance,
                                   DebuggerInitialize);
 
     Log::Callbacks log_callbacks = {ProcessKDPLog::DisableLog,
                                     ProcessKDPLog::EnableLog,
                                     ProcessKDPLog::ListLogCategories};
 

source/Plugins/Process/POSIX/ProcessPOSIXLog.cpp

 
 #include "ProcessPOSIXLog.h"
 
 #include <mutex>
 
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/Args.h"
 
+#include "llvm/Support/Threading.h"
+
 #include "ProcessPOSIXLog.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 // We want to avoid global constructors where code needs to be run so here we
 // control access to our static g_log_sp by hiding it in a singleton function
 // that will construct the static g_log_sp the first time this function is
 // called.
 static bool g_log_enabled = false;
 static Log *g_log = NULL;
 static Log *GetLog() {
   if (!g_log_enabled)
     return NULL;
   return g_log;
 }
 
 void ProcessPOSIXLog::Initialize(ConstString name) {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, [name]() {
+  llvm::call_once(g_once_flag, [name]() {
     Log::Callbacks log_callbacks = {DisableLog, EnableLog, ListLogCategories};
 
     Log::RegisterLogChannel(name, log_callbacks);
     RegisterPluginName(name);
   });
 }
 
 Log *ProcessPOSIXLog::GetLogIfAllCategoriesSet(uint32_t mask) {

source/Plugins/Process/Windows/Common/ProcessWindows.cpp

 #include "ExceptionRecord.h"
 #include "ForwardDecl.h"
 #include "LocalDebugDelegate.h"
 #include "ProcessWindowsLog.h"
 #include "TargetThreadWindows.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 namespace {
 std::string GetProcessExecutableName(HANDLE process_handle) {
   std::vector<wchar_t> file_name;
   DWORD file_name_size = MAX_PATH; // first guess, not an absolute limit
   DWORD copied = 0;
   do {
     file_name_size *= 2;

 
 ProcessSP ProcessWindows::CreateInstance(lldb::TargetSP target_sp,
                                          lldb::ListenerSP listener_sp,
                                          const FileSpec *) {
   return ProcessSP(new ProcessWindows(target_sp, listener_sp));
 }
 
 void ProcessWindows::Initialize() {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(), CreateInstance);
   });
 }
 
 void ProcessWindows::Terminate() {}
 
 lldb_private::ConstString ProcessWindows::GetPluginNameStatic() {

source/Plugins/Process/Windows/Common/ProcessWindowsLog.cpp

 #include <mutex>
 
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/Args.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 // We want to avoid global constructors where code needs to be run so here we
 // control access to our static g_log_sp by hiding it in a singleton function
 // that will construct the static g_log_sp the first time this function is
 // called.
 static bool g_log_enabled = false;
 static Log *g_log = nullptr;
 
-static llvm::ManagedStatic<std::once_flag> g_once_flag;
+LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
 void ProcessWindowsLog::Initialize() {
   static ConstString g_name("windows");
 
-  std::call_once(*g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     Log::Callbacks log_callbacks = {DisableLog, EnableLog, ListLogCategories};
 
     Log::RegisterLogChannel(g_name, log_callbacks);
     RegisterPluginName(g_name);
   });
 }
 
 void ProcessWindowsLog::Terminate() {}

source/Plugins/Process/elf-core/ProcessElfCore.cpp

 #include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 
 #include "llvm/Support/ELF.h"
+#include "llvm/Support/Threading.h"
 
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 
 // Project includes
 #include "ProcessElfCore.h"
 #include "ThreadElfCore.h"
 
 using namespace lldb_private;
+using namespace llvm;
 
 ConstString ProcessElfCore::GetPluginNameStatic() {
   static ConstString g_name("elf-core");
   return g_name;
 }
 
 const char *ProcessElfCore::GetPluginDescriptionStatic() {
   return "ELF core dump plug-in.";

 void ProcessElfCore::Clear() {
   m_thread_list.Clear();
   m_os = llvm::Triple::UnknownOS;
 
   SetUnixSignals(std::make_shared<UnixSignals>());
 }
 
 void ProcessElfCore::Initialize() {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(), CreateInstance);
   });
 }
 
 lldb::addr_t ProcessElfCore::GetImageInfoAddress() {
   ObjectFile *obj_file = GetTarget().GetExecutableModule()->GetObjectFile();
   Address addr = obj_file->GetImageInfoAddress(&GetTarget());

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/JSON.h"
 
+#include "llvm/Support/Threading.h"
+
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "Utility/UriParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
+using namespace llvm;
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerPlatform constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(
     const Socket::SocketProtocol socket_protocol, const char *socket_scheme)
     : GDBRemoteCommunicationServerCommon("gdb-remote.server",
                                          "gdb-remote.server.rx_packet"),
for (auto &pair : m_port_map) {
       }
     }
   }
   return false;
 }
 
 const FileSpec &GDBRemoteCommunicationServerPlatform::GetDomainSocketDir() {
   static FileSpec g_domainsocket_dir;
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     const char *domainsocket_dir_env =
         ::getenv("LLDB_DEBUGSERVER_DOMAINSOCKET_DIR");
     if (domainsocket_dir_env != nullptr)
       g_domainsocket_dir = FileSpec(domainsocket_dir_env, false);
     else
       HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, g_domainsocket_dir);
   });
 

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 #include "Utility/StringExtractorGDBRemote.h"
 #include "lldb/Host/Host.h"
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Threading.h"
 
 #define DEBUGSERVER_BASENAME "debugserver"
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
+using namespace llvm;
 
 namespace lldb {
 // Provide a function that can easily dump the packet history if we know a
 // ProcessGDBRemote * value (which we can get from logs or from debugging).
 // We need the function in the lldb namespace so it makes it into the final
 // executable since the LLDB shared library only exports stuff in the lldb
 // namespace. This allows you to attach with a debugger and call this
 // function and get the packet history dumped to a file.

   m_gdb_comm.Disconnect();
   if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) {
     Host::Kill(m_debugserver_pid, SIGINT);
     m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
   }
 }
 
 void ProcessGDBRemote::Initialize() {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(), CreateInstance,
                                   DebuggerInitialize);
   });
 }
 
 void ProcessGDBRemote::DebuggerInitialize(Debugger &debugger) {
   if (!PluginManager::GetSettingForProcessPlugin(

source/Plugins/Process/gdb-remote/ProcessGDBRemoteLog.cpp

 //===-- ProcessGDBRemoteLog.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ProcessGDBRemoteLog.h"
 
 #include <mutex>
 
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/Args.h"
 
+#include "llvm/Support/Threading.h"
+
 #include "ProcessGDBRemote.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
+using namespace llvm;
 
 // We want to avoid global constructors where code needs to be run so here we
 // control access to our static g_log_sp by hiding it in a singleton function
 // that will construct the static g_lob_sp the first time this function is
 // called.
 static bool g_log_enabled = false;
 static Log *g_log = NULL;
 static Log *GetLog() {
   if (!g_log_enabled)
     return NULL;
   return g_log;
 }
 
 void ProcessGDBRemoteLog::Initialize() {
   static ConstString g_name("gdb-remote");
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     Log::Callbacks log_callbacks = {DisableLog, EnableLog, ListLogCategories};
 
     Log::RegisterLogChannel(g_name, log_callbacks);
   });
 }
 
 Log *ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(uint32_t mask) {
   Log *log(GetLog());

source/Plugins/Process/mach-core/ProcessMachCore.cpp

 // Project includes
 #include "ProcessMachCore.h"
 #include "StopInfoMachException.h"
 #include "ThreadMachCore.h"
 
 // Needed for the plug-in names for the dynamic loaders.
 #include "lldb/Utility/SafeMachO.h"
 
+#include "llvm/Support/Threading.h"
+
 #include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
 #include "Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h"
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 ConstString ProcessMachCore::GetPluginNameStatic() {
   static ConstString g_name("mach-o-core");
   return g_name;
 }
 
 const char *ProcessMachCore::GetPluginDescriptionStatic() {
   return "Mach-O core file debugging plug-in.";
Error ProcessMachCore::GetMemoryRegionInfo(addr_t load_addr,
   region_info.SetExecutable(MemoryRegionInfo::eNo);
   region_info.SetMapped(MemoryRegionInfo::eNo);
   return Error();
 }
 
 void ProcessMachCore::Clear() { m_thread_list.Clear(); }
 
 void ProcessMachCore::Initialize() {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(), CreateInstance);
   });
 }
 
 addr_t ProcessMachCore::GetImageInfoAddress() {
   // If we found both a user-process dyld and a kernel binary, we need to decide
   // which to prefer.

source/Plugins/Process/minidump/ProcessMinidump.cpp

 #include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/LLDBAssert.h"
 
+#include "llvm/Support/Threading.h"
+
 // C includes
 // C++ includes
 
 using namespace lldb_private;
 using namespace minidump;
+using namespace llvm;
 
 ConstString ProcessMinidump::GetPluginNameStatic() {
   static ConstString g_name("minidump");
   return g_name;
 }
 
 const char *ProcessMinidump::GetPluginDescriptionStatic() {
   return "Minidump plug-in.";
ProcessMinidump::~ProcessMinidump() {
   // We need to call finalize on the process before destroying ourselves
   // to make sure all of the broadcaster cleanup goes as planned. If we
   // destruct this class, then Process::~Process() might have problems
   // trying to fully destroy the broadcaster.
   Finalize();
 }
 
 void ProcessMinidump::Initialize() {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(),
                                   ProcessMinidump::CreateInstance);
   });
 }
 
 void ProcessMinidump::Terminate() {
   PluginManager::UnregisterPlugin(ProcessMinidump::CreateInstance);

source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

 #include "ScriptInterpreterNone.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StringList.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 
+#include "llvm/Support/Threading.h"
+
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 ScriptInterpreterNone::ScriptInterpreterNone(CommandInterpreter &interpreter)
     : ScriptInterpreter(interpreter, eScriptLanguageNone) {}
 
 ScriptInterpreterNone::~ScriptInterpreterNone() {}
 
 bool ScriptInterpreterNone::ExecuteOneLine(const char *command,
                                            CommandReturnObject *,
                                            const ExecuteScriptOptions &) {
   m_interpreter.GetDebugger().GetErrorFile()->PutCString(
       "error: there is no embedded script interpreter in this mode.\n");
   return false;
 }
 
 void ScriptInterpreterNone::ExecuteInterpreterLoop() {
   m_interpreter.GetDebugger().GetErrorFile()->PutCString(
       "error: there is no embedded script interpreter in this mode.\n");
 }
 
 void ScriptInterpreterNone::Initialize() {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(),
                                   lldb::eScriptLanguageNone, CreateInstance);
   });
 }
 
 void ScriptInterpreterNone::Terminate() {}
 

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 #include "lldb/Target/ThreadPlan.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
 #endif
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Threading.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 static ScriptInterpreterPython::SWIGInitCallback g_swig_init_callback = nullptr;
 static ScriptInterpreterPython::SWIGBreakpointCallbackFunction
     g_swig_breakpoint_callback = nullptr;
 static ScriptInterpreterPython::SWIGWatchpointCallbackFunction
     g_swig_watchpoint_callback = nullptr;
 static ScriptInterpreterPython::SWIGPythonTypeScriptCallbackFunction
     g_swig_typescript_callback = nullptr;
ScriptInterpreterPython::~ScriptInterpreterPython() {
   // and then release it for others to use and proceed with the rest of the
   // shutdown
   auto gil_state = PyGILState_Ensure();
   m_session_dict.Reset();
   PyGILState_Release(gil_state);
 }
 
 void ScriptInterpreterPython::Initialize() {
-  static std::once_flag g_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
 
-  std::call_once(g_once_flag, []() {
+  llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(),
                                   lldb::eScriptLanguagePython, CreateInstance);
   });
 }
 
 void ScriptInterpreterPython::Terminate() {}
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
   typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
 
   struct DWARFDataSegment {
-    std::once_flag m_flag;
     lldb_private::DWARFDataExtractor m_data;
   };
 
   DISALLOW_COPY_AND_ASSIGN(SymbolFileDWARF);
 
   const lldb_private::DWARFDataExtractor &
   GetCachedSectionData(lldb::SectionType sect_type,
                        DWARFDataSegment &data_segment);

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 //===-- SymbolFileDWARF.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileDWARF.h"
 
 // Other libraries and framework includes
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Threading.h"
 
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Scalar.h"

 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm;
 
 // static inline bool
 // child_requires_parent_class_union_or_struct_to_be_completed (dw_tag_t tag)
 //{
 //    switch (tag)
 //    {
 //    default:
 //        break;
if (debug_line_file_size > 0)
       abilities |= LineTables;
   }
   return abilities;
 }
 
 const DWARFDataExtractor &
 SymbolFileDWARF::GetCachedSectionData(lldb::SectionType sect_type,
                                       DWARFDataSegment &data_segment) {
-  std::call_once(data_segment.m_flag, &SymbolFileDWARF::LoadSectionData, this,
-                 sect_type, std::ref(data_segment.m_data));
+  LLVM_DEFINE_ONCE_FLAG(m_flag);
+  llvm::call_once(m_flag,  [this, sect_type, &data_segment]{ this->LoadSectionData(sect_type, std::ref(data_segment.m_data));});
   return data_segment.m_data;
 }
 
 void SymbolFileDWARF::LoadSectionData(lldb::SectionType sect_type,
                                       DWARFDataExtractor &data) {
   ModuleSP module_sp(m_obj_file->GetModule());
   const SectionList *section_list = module_sp->GetSectionList();
   if (section_list) {
if (module_sp) {
         if (cu_sp) {
           VariableListSP globals_sp = cu_sp->GetVariableList(true);
           if (globals_sp) {
             const size_t num_globals = globals_sp->GetSize();
             for (size_t g = 0; g < num_globals; ++g) {
               VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
               if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
                 const DWARFExpression &location = var_sp->LocationExpression();
-                Value location_result;
+                lldb_private::Value location_result;
                 Error error;
                 if (location.Evaluate(nullptr, nullptr, nullptr,
                                       LLDB_INVALID_ADDRESS, nullptr, nullptr,
                                       location_result, &error)) {
                   if (location_result.GetValueType() ==
-                      Value::eValueTypeFileAddress) {
+                      lldb_private::Value::eValueTypeFileAddress) {
                     lldb::addr_t file_addr =
                         location_result.GetScalar().ULongLong();
                     lldb::addr_t byte_size = 1;
                     if (var_sp->GetType())
                       byte_size = var_sp->GetType()->GetByteSize();
                     m_global_aranges_ap->Append(GlobalVariableMap::Entry(
                         file_addr, byte_size, var_sp.get()));
                   }

source/Symbol/ClangASTContext.cpp

 }
 }
 
 typedef lldb_private::ThreadSafeDenseMap<clang::ASTContext *, ClangASTContext *>
     ClangASTMap;
 
 static ClangASTMap &GetASTMap() {
   static ClangASTMap *g_map_ptr = nullptr;
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
+  LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+  llvm::call_once(g_once_flag, []() {
     g_map_ptr = new ClangASTMap(); // leaked on purpose to avoid spins
   });
   return *g_map_ptr;
 }
 
 static bool IsOperator(const char *name,
                        clang::OverloadedOperatorKind &op_kind) {
   if (name == nullptr || name[0] == '\0')
CompilerType ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(
   return CompilerType();
 }
 
 lldb::BasicType
 ClangASTContext::GetBasicTypeEnumeration(const ConstString &name) {
   if (name) {
     typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
     static TypeNameToBasicTypeMap g_type_map;
-    static std::once_flag g_once_flag;
-    std::call_once(g_once_flag, []() {
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+    llvm::call_once(g_once_flag, []() {
       // "void"
       g_type_map.Append(ConstString("void").GetStringRef(), eBasicTypeVoid);
 
       // "char"
       g_type_map.Append(ConstString("char").GetStringRef(), eBasicTypeChar);
       g_type_map.Append(ConstString("signed char").GetStringRef(),
                         eBasicTypeSignedChar);
       g_type_map.Append(ConstString("unsigned char").GetStringRef(),

source/Symbol/GoASTContext.cpp

 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/GoASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 
+#include "llvm/Support/Threading.h"
+
 #include "Plugins/ExpressionParser/Go/GoUserExpression.h"
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserGo.h"
 
 using namespace lldb;
+using namespace llvm;
 
 namespace lldb_private {
 class GoArray;
 class GoFunction;
 class GoStruct;
 
 class GoType {
 public:

 }
 
 lldb::BasicType
 GoASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
   ConstString name = GetTypeName(type);
   if (name) {
     typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
     static TypeNameToBasicTypeMap g_type_map;
-    static std::once_flag g_once_flag;
-    std::call_once(g_once_flag, []() {
+    LLVM_DEFINE_ONCE_FLAG(g_once_flag);
+    llvm::call_once(g_once_flag, []() {
       // "void"
       g_type_map.Append(ConstString("void").GetStringRef(), eBasicTypeVoid);
       // "int"
       g_type_map.Append(ConstString("int").GetStringRef(), eBasicTypeInt);
       g_type_map.Append(ConstString("uint").GetStringRef(),
                         eBasicTypeUnsignedInt);
 
       // Miscellaneous

source/Target/Language.cpp

 #include "lldb/Target/Language.h"
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Target.h"
 
+#include "llvm/Support/Threading.h"
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
+using namespace llvm;
 
 typedef std::unique_ptr<Language> LanguageUP;
 typedef std::map<lldb::LanguageType, LanguageUP> LanguagesMap;
 
 static LanguagesMap &GetLanguagesMap() {
   static LanguagesMap *g_map = nullptr;
-  static std::once_flag g_initialize;
+  LLVM_DEFINE_ONCE_FLAG(g_initialize);
 
-  std::call_once(g_initialize, [] {
+  llvm::call_once(g_initialize, [] {
     g_map = new LanguagesMap(); // NOTE: INTENTIONAL LEAK due to global
                                 // destructor chain
   });
 
   return *g_map;
 }
 static std::mutex &GetLanguagesMutex() {
   static std::mutex *g_mutex = nullptr;
-  static std::once_flag g_initialize;
+  LLVM_DEFINE_ONCE_FLAG(g_initialize);
 
-  std::call_once(g_initialize, [] {
+  llvm::call_once(g_initialize, [] {
     g_mutex = new std::mutex(); // NOTE: INTENTIONAL LEAK due to global
                                 // destructor chain
   });
 
   return *g_mutex;
 }
 
 Language *Language::FindPlugin(lldb::LanguageType language) {

tools/debugserver/source/MacOSX/DarwinLog/DarwinLogCollector.cpp

 static os_activity_stream_for_pid_t s_os_activity_stream_for_pid;
 static os_activity_stream_resume_t s_os_activity_stream_resume;
 static os_activity_stream_cancel_t s_os_activity_stream_cancel;
 static os_log_copy_formatted_message_t s_os_log_copy_formatted_message;
 static os_activity_stream_set_event_handler_t
     s_os_activity_stream_set_event_handler;
 
 bool LookupSPICalls() {
-  static std::once_flag s_once_flag;
+  LLVM_DEFINE_ONCE_FLAG(s_once_flag);
   static bool s_has_spi;
 
-  std::call_once(s_once_flag, [] {
+  llvm::call_once(s_once_flag, [] {
     dlopen ("/System/Library/PrivateFrameworks/LoggingSupport.framework/LoggingSupport", RTLD_NOW);
     s_os_activity_stream_for_pid = (os_activity_stream_for_pid_t)dlsym(
         RTLD_DEFAULT, "os_activity_stream_for_pid");
     s_os_activity_stream_resume = (os_activity_stream_resume_t)dlsym(
         RTLD_DEFAULT, "os_activity_stream_resume");
     s_os_activity_stream_cancel = (os_activity_stream_cancel_t)dlsym(
         RTLD_DEFAULT, "os_activity_stream_cancel");
     s_os_log_copy_formatted_message = (os_log_copy_formatted_message_t)dlsym(