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 ↗

(On Diff #86302)

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 ↗

(On Diff #86302)

Why was this added? Remove if not needed.

768–769 ↗

(On Diff #86302)

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 ↗

(On Diff #86302)

Why was this using added? Remove please.

source/Host/common/Editline.cpp

27 ↗

(On Diff #86302)

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 ↗

(On Diff #86302)

Remove

source/Host/linux/HostInfoLinux.cpp

22 ↗

(On Diff #86302)

Remove

source/Host/windows/HostInfoWindows.cpp

24 ↗

(On Diff #86302)

Remove

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

38 ↗

(On Diff #86302)

Remove

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

47 ↗

(On Diff #86302)

Remove

source/Plugins/Language/Go/GoLanguage.cpp

30 ↗

(On Diff #86302)

Remove

source/Plugins/Language/Java/JavaLanguage.cpp

32 ↗

(On Diff #86302)

Remove

source/Plugins/Language/ObjC/ObjCLanguage.cpp

39 ↗

(On Diff #86302)

Remove

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

51 ↗

(On Diff #86302)

Remove

source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

51 ↗

(On Diff #86302)

Remove

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

53 ↗

(On Diff #86302)

Remove

source/Plugins/Process/POSIX/ProcessPOSIXLog.cpp

24 ↗

(On Diff #86302)

Remove

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

44 ↗

(On Diff #86302)

Remove

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

20 ↗

(On Diff #86302)

Remove

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

40 ↗

(On Diff #86302)

rm

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

48 ↗

(On Diff #86302)

rm

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

90 ↗

(On Diff #86302)

rm

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

24 ↗

(On Diff #86302)

rm

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

50 ↗

(On Diff #86302)

rm

source/Plugins/Process/minidump/ProcessMinidump.cpp

35 ↗

(On Diff #86302)

rm

source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

24 ↗

(On Diff #86302)

rm

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

58 ↗

(On Diff #86302)

rm

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

91 ↗

(On Diff #86302)

rm

558–559 ↗

(On Diff #86302)

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

1635 ↗

(On Diff #86302)

Revert since we shouldn't include llvm namespace.

1641 ↗

(On Diff #86302)

Revert since we shouldn't include llvm namespace.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

307 ↗

(On Diff #86302)

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

source/Symbol/GoASTContext.cpp

34 ↗

(On Diff #86302)

rm

source/Target/Language.cpp

28 ↗

(On Diff #86302)

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

379 ↗

(On Diff #87120)

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

648 ↗

(On Diff #87120)

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

379 ↗

(On Diff #87120)

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

379 ↗

(On Diff #87153)

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

379 ↗

(On Diff #87153)

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!

lldb/trunk/include/lldb/Core/Debugger.h

 #include "lldb/Core/UserID.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/lldb-public.h"
 
+#include "llvm/Support/Threading.h"
+
 namespace llvm {
 namespace sys {
 class DynamicLibrary;
 } // namespace sys
 } // namespace llvm
 
 namespace lldb_private {
 
protected:
   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;
+  llvm::once_flag m_clear_once;
 
   //----------------------------------------------------------------------
   // Events for m_sync_broadcaster
   //----------------------------------------------------------------------
   enum {
     eBroadcastBitEventThreadIsListening = (1 << 0),
   };
 

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

 #include "lldb/Interpreter/CommandReturnObject.h"
 #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 "llvm/ADT/SmallString.h"
+#include "llvm/Support/Threading.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static mode_t ParsePermissionString(const char *) = delete;
 
 static mode_t ParsePermissionString(llvm::StringRef permissions) {
   if (permissions.size() != 9)
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, []() {
+      static llvm::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':

lldb/trunk/source/Core/Debugger.cpp

 // C Includes
 // C++ Includes
 #include <map>
 #include <mutex>
 
 // Other libraries and framework includes
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DynamicLibrary.h"
+#include "llvm/Support/Threading.h"
 
 // Project includes
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/State.h"
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::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) {

lldb/trunk/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;
 
 ModuleList::ModuleList()
     : m_modules(), m_modules_mutex(), m_notifier(nullptr) {}
 
 ModuleList::ModuleList(const ModuleList &rhs)
     : m_modules(), m_modules_mutex(), m_notifier(nullptr) {
for (pos = begin; pos != end; ++pos) {
         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, []() {
+  static llvm::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;
 }

lldb/trunk/source/Host/common/Editline.cpp

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/SelectHelper.h"
 #include "lldb/Utility/StreamString.h"
 
+#include "llvm/Support/Threading.h"
+
 using namespace lldb_private;
 using namespace lldb_private::line_editor;
 
 // 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
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, [&]() {
+      static llvm::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

lldb/trunk/source/Host/common/HostInfoBase.cpp

 #include "lldb/Host/HostInfoBase.h"
 #include "lldb/Utility/StreamString.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 <mutex>
 #include <thread>
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 //----------------------------------------------------------------------
 // The HostInfoBaseFields is a work around for windows not supporting

 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, []() {
+  static llvm::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, []() {
+  static llvm::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, []() {
+  static llvm::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, []() {
+  static llvm::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, []() {
+  static llvm::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;
+    static llvm::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;
+    static llvm::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;
+    static llvm::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;
+    static llvm::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;
+    static llvm::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;
+    static llvm::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;
+    static llvm::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;
+    static llvm::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;
+    static llvm::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());
     });

lldb/trunk/source/Host/linux/HostInfoLinux.cpp

 //===-- HostInfoLinux.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/linux/HostInfoLinux.h"
 #include "lldb/Core/Log.h"
 
+#include "llvm/Support/Threading.h"
+
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/utsname.h>
 
 #include <algorithm>
 #include <mutex> // std::once
 
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, []() {
+  static llvm::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, []() {
+  static llvm::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",

lldb/trunk/source/Host/windows/HostInfoWindows.cpp

 
 #include <mutex> // std::once
 
 #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/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace lldb_private;
 
 FileSpec HostInfoWindows::m_program_filespec;
 
 void HostInfoWindows::Initialize() {
   ::CoInitializeEx(nullptr, COINIT_MULTITHREADED);
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, []() {
+  static llvm::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;
 }

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Serialization/ASTReader.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Threading.h"
 
 // Project includes
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Core/Log.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
case clang::DiagnosticsEngine::Level::Ignored:
       break;
     }
   }
 }
 
 static FileSpec GetResourceDir() {
   static FileSpec g_cached_resource_dir;
 
-  static std::once_flag g_once_flag;
+  static llvm::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() {}
 

lldb/trunk/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

 // C++ Includes
 #include <functional>
 #include <memory>
 #include <mutex>
 #include <set>
 
 // Other libraries and framework includes
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Threading.h"
 
 // Project includes
 #include "lldb/Core/FastDemangle.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/DataFormatters/CXXFunctionPointer.h"
 #include "lldb/DataFormatters/DataVisualization.h"
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;
+  static llvm::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;
+  static llvm::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;
+  static llvm::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)

lldb/trunk/source/Plugins/Language/Go/GoLanguage.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 "GoLanguage.h"
 #include "Plugins/Language/Go/GoFormatterFunctions.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/GoASTContext.h"
 #include "lldb/Utility/ConstString.h"

 Language *GoLanguage::CreateInstance(lldb::LanguageType language) {
   if (language == eLanguageTypeGo)
     return new GoLanguage();
   return nullptr;
 }
 
 HardcodedFormatters::HardcodedSummaryFinder
 GoLanguage::GetHardcodedSummaries() {
-  static std::once_flag g_initialize;
+  static llvm::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;
+  static llvm::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;
 }

lldb/trunk/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/PluginManager.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/JavaASTContext.h"
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;
+  static llvm::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"));

lldb/trunk/source/Plugins/Language/ObjC/ObjCLanguage.cpp

 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/StreamString.h"
 
+#include "llvm/Support/Threading.h"
+
 #include "CF.h"
 #include "Cocoa.h"
 #include "CoreMedia.h"
 #include "NSDictionary.h"
 #include "NSSet.h"
 #include "NSString.h"
 
 using namespace lldb;

 #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;
+  static llvm::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;
 }

lldb/trunk/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] {
+  static llvm::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__)

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #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 "lldb/Utility/Error.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;
 
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, []() {
+  static llvm::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, []() {
+  static llvm::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");

lldb/trunk/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 
 #include "lldb/Host/posix/Fcntl.h"
 
+#include "llvm/Support/Threading.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 UnixSignalsSP &GetFreeBSDSignals() {
   static UnixSignalsSP s_freebsd_signals_sp(new FreeBSDSignals());
   return s_freebsd_signals_sp;
 }
ProcessFreeBSD::CreateInstance(lldb::TargetSP target_sp,
   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;
+  static llvm::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");

lldb/trunk/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;
+  static llvm::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;

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

 #include "lldb/Interpreter/OptionGroupUInt64.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/StringExtractor.h"
 
+#include "llvm/Support/Threading.h"
+
 #define USEC_PER_SEC 1000000
 
 // Project includes
 #include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
 #include "ProcessKDP.h"
 #include "ProcessKDPLog.h"
 #include "ThreadKDP.h"

 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;
+  static llvm::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};
 

lldb/trunk/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;
 
 // 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;
+  static llvm::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) {

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

 #include "lldb/Host/windows/windows.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "DebuggerThread.h"
 #include "ExceptionRecord.h"
 #include "ForwardDecl.h"
 #include "LocalDebugDelegate.h"
 #include "ProcessWindowsLog.h"
 #include "TargetThreadWindows.h"

 
 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;
+  static llvm::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() {

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

 //===-- ProcessWindowsLog.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ProcessWindowsLog.h"
 
 #include <mutex>
 
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/Args.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Threading.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // 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;
+static llvm::ManagedStatic<llvm::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() {}

lldb/trunk/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"
 

 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;
+  static llvm::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());

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

 // C++ Includes
 #include <chrono>
 #include <cstring>
 #include <mutex>
 #include <sstream>
 
 // Other libraries and framework includes
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Threading.h"
 
 #include "lldb/Core/Log.h"
 #include "lldb/Core/StreamGDBRemote.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
for (auto &pair : m_port_map) {
       }
     }
   }
   return false;
 }
 
 const FileSpec &GDBRemoteCommunicationServerPlatform::GetDomainSocketDir() {
   static FileSpec g_domainsocket_dir;
-  static std::once_flag g_once_flag;
+  static llvm::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);
   });
 

lldb/trunk/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;
 
 namespace lldb {
 // Provide a function that can easily dump the packet history if we know a
void ProcessGDBRemote::KillDebugserverProcess() {
   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;
+  static llvm::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(

lldb/trunk/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;
 
 // 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;
+  static llvm::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());

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

 //===-- ProcessMachCore.cpp ------------------------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 #include <errno.h>
 #include <stdlib.h>
 
 // C++ Includes
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Threading.h"
 #include <mutex>
 
 // Other libraries and framework includes
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
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;
+  static llvm::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.

lldb/trunk/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;
 
 ConstString ProcessMinidump::GetPluginNameStatic() {
   static ConstString g_name("minidump");
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;
+  static llvm::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);

lldb/trunk/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

 #include "ScriptInterpreterNone.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StringList.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Utility/Stream.h"
 
+#include "llvm/Support/Threading.h"
+
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;
 
 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;
+  static llvm::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() {}
 

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

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;
+  static llvm::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() {}
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 #include <map>
 #include <mutex>
 #include <set>
 #include <unordered_map>
 #include <vector>
 
 // Other libraries and framework includes
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/Threading.h"
 
 #include "lldb/Core/Flags.h"
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
protected:
   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;
+    llvm::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);

lldb/trunk/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/Scalar.h"
 #include "lldb/Core/Section.h"
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::call_once(data_segment.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) {

lldb/trunk/source/Symbol/ClangASTContext.cpp

 //===-- ClangASTContext.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/ClangASTContext.h"
 
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"
 
 // C Includes
 // C++ Includes
-#include <mutex> // std::once
+#include <mutex>
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 
 // Clang headers like to use NDEBUG inside of them to enable/disable debug
 // related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
 // or another. This is bad because it means that if clang was built in release

 #ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
 #undef NDEBUG
 #undef LLDB_DEFINED_NDEBUG_FOR_CLANG
 // Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
 #include <assert.h>
 #endif
 
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/Threading.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h"
 #include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Flags.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"

 }
 }
 
 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, []() {
+  static llvm::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, []() {
+    static llvm::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(),

lldb/trunk/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;
 
 namespace lldb_private {
 class GoArray;
 class GoFunction;

 }
 
 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, []() {
+    static llvm::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

lldb/trunk/source/Target/Language.cpp

 #include "lldb/Target/Language.h"
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Stream.h"
 
+#include "llvm/Support/Threading.h"
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 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;
+  static llvm::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;
+  static llvm::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) {

lldb/trunk/source/Utility/ConstString.cpp

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

 // 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;
+  static llvm::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)) {}
 

lldb/trunk/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;
+  static llvm::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(