Simplify GetGlobalProperties functions of Thread/Process/Target

[labath]

Summary

"Initialization of function-local statics is guaranteed to occur only once even when called from
multiple threads, and may be more efficient than the equivalent code using std::call_once."
http://en.cppreference.com/w/cpp/thread/call_once

I'd add that it's also more readable.

[zturner]

The reason for this is that msvc didn't support this until 2015. I'm fine
with these changes but i think you guys still need 2013 for a while longer,
right?

[labath]

I suspected something like that might be up. Thanks.

The VS2015 migration for us is taking longer than expected, but we are now nearing the end, hopefully. If there are no objections, I'll land this after we are done.

[clayborg]

Looks good to me, commit when you know this will work with MSVC versions you need. All other platforms will be good to go.

lldb/trunk/source/Target/Process.cpp

Process::~Process() {
   // explicitly clear the thread list here to ensure that the mutex
   // is not destroyed before the thread list.
   m_thread_list.Clear();
 }
 
 const ProcessPropertiesSP &Process::GetGlobalProperties() {
   // NOTE: intentional leak so we don't crash if global destructor chain gets
   // called as other threads still use the result of this function
-  static ProcessPropertiesSP *g_settings_sp_ptr = nullptr;
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
-    g_settings_sp_ptr = new ProcessPropertiesSP(new ProcessProperties(nullptr));
-  });
+  static ProcessPropertiesSP *g_settings_sp_ptr =
+      new ProcessPropertiesSP(new ProcessProperties(nullptr));
   return *g_settings_sp_ptr;
 }
 
 void Process::Finalize() {
   m_finalizing = true;
 
   // Destroy this process if needed
   switch (GetPrivateState()) {

lldb/trunk/source/Target/Target.cpp

void Target::RunStopHooks() {
 
   result.GetImmediateOutputStream()->Flush();
   result.GetImmediateErrorStream()->Flush();
 }
 
 const TargetPropertiesSP &Target::GetGlobalProperties() {
   // NOTE: intentional leak so we don't crash if global destructor chain gets
   // called as other threads still use the result of this function
-  static TargetPropertiesSP *g_settings_sp_ptr = nullptr;
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
-    g_settings_sp_ptr = new TargetPropertiesSP(new TargetProperties(nullptr));
-  });
+  static TargetPropertiesSP *g_settings_sp_ptr =
+      new TargetPropertiesSP(new TargetProperties(nullptr));
   return *g_settings_sp_ptr;
 }
 
 Error Target::Install(ProcessLaunchInfo *launch_info) {
   Error error;
   PlatformSP platform_sp(GetPlatform());
   if (platform_sp) {
     if (platform_sp->IsRemote()) {

lldb/trunk/source/Target/Thread.cpp

 #include "lldb/Target/Unwind.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const ThreadPropertiesSP &Thread::GetGlobalProperties() {
   // NOTE: intentional leak so we don't crash if global destructor chain gets
   // called as other threads still use the result of this function
-  static ThreadPropertiesSP *g_settings_sp_ptr = nullptr;
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, []() {
-    g_settings_sp_ptr = new ThreadPropertiesSP(new ThreadProperties(true));
-  });
+  static ThreadPropertiesSP *g_settings_sp_ptr =
+      new ThreadPropertiesSP(new ThreadProperties(true));
   return *g_settings_sp_ptr;
 }
 
 static PropertyDefinition g_properties[] = {
     {"step-in-avoid-nodebug", OptionValue::eTypeBoolean, true, true, nullptr,
      nullptr,
      "If true, step-in will not stop in functions with no debug information."},
     {"step-out-avoid-nodebug", OptionValue::eTypeBoolean, true, false, nullptr,