[lldb] Make the thread_local g_global_boundary accessed from a single file

[mstorsjo]

Summary

This makes the compiler generated code for accessing the thread local
variable much simpler (no need for wrapper functions and weak pointers
to potential init functions), and can avoid toolchain bugs regarding how
to access TLS variables.

In particular, this fixes LLDB when built with current GCC/binutils for
MinGW, see https://github.com/msys2/MINGW-packages/issues/8868.

[labath]

Seems straight-forward enough, though I am wondering how much of this code is actually necessary given the deprecation/repurposing of reproducers.

lldb/include/lldb/Utility/ReproducerInstrumentation.h

if (update_boundary)
       UpdateBoundary();
     return std::forward<Result>(r);
   }
 
   bool ShouldCapture() { return m_local_boundary; }
 
   /// Mark the current thread as a private thread and pretend that everything
   /// on this thread is behind happening behind the API boundary.
-  static void PrivateThread() { g_global_boundary = true; }
+  static void PrivateThread();
 
 private:
   static unsigned GetNextSequenceNumber() { return g_sequence++; }
   unsigned GetSequenceNumber() const;
 
   template <typename T> friend struct replay;
-  void UpdateBoundary() {
-    if (m_local_boundary)
-      g_global_boundary = false;
-  }
+  void UpdateBoundary();
 
 #ifdef LLDB_REPRO_INSTR_TRACE
   void Log(unsigned id) {
     this_thread_id() << "Recording " << id << ": " << m_pretty_func << " ("
                      << m_pretty_args << ")\n";
   }
 #endif
 
   Serializer *m_serializer = nullptr;
 
   /// Pretty function for logging.
   llvm::StringRef m_pretty_func;
   std::string m_pretty_args;
 
   /// Whether this function call was the one crossing the API boundary.
   bool m_local_boundary = false;
 
   /// Whether the return value was recorded explicitly.
   bool m_result_recorded = true;
 
   /// The sequence number for this pair of function and result.
   unsigned m_sequence;
 
-  /// Whether we're currently across the API boundary.
-  static thread_local bool g_global_boundary;
-
   /// Global mutex to protect concurrent access.
   static std::mutex g_mutex;
 
   /// Unique, monotonically increasing sequence number.
   static std::atomic<unsigned> g_sequence;
 };
 
 /// To be used as the "Runtime ID" of a constructor. It also invokes the

lldb/source/Utility/ReproducerInstrumentation.cpp

 #include <cstdio>
 #include <cstdlib>
 #include <limits>
 #include <thread>
 
 using namespace lldb_private;
 using namespace lldb_private::repro;
 
+// Whether we're currently across the API boundary.
+static thread_local bool g_global_boundary = false;
+
 void *IndexToObject::GetObjectForIndexImpl(unsigned idx) {
   return m_mapping.lookup(idx);
 }
 
 void IndexToObject::AddObjectForIndexImpl(unsigned idx, void *object) {
   assert(idx != 0 && "Cannot add object for sentinel");
   m_mapping[idx] = object;
 }
Recorder::~Recorder() {
   UpdateBoundary();
 }
 
 unsigned Recorder::GetSequenceNumber() const {
   assert(m_sequence != std::numeric_limits<unsigned>::max());
   return m_sequence;
 }
 
+void Recorder::PrivateThread() { g_global_boundary = true; }
+
+void Recorder::UpdateBoundary() {
+  if (m_local_boundary)
+    g_global_boundary = false;
+}
+
 void InstrumentationData::Initialize(Serializer &serializer,
                                      Registry &registry) {
   InstanceImpl().emplace(serializer, registry);
 }
 
 void InstrumentationData::Initialize(Deserializer &deserializer,
                                      Registry &registry) {
   InstanceImpl().emplace(deserializer, registry);
 }
 
 InstrumentationData &InstrumentationData::Instance() {
   if (!InstanceImpl())
     InstanceImpl().emplace();
   return *InstanceImpl();
 }
 
 llvm::Optional<InstrumentationData> &InstrumentationData::InstanceImpl() {
   static llvm::Optional<InstrumentationData> g_instrumentation_data;
   return g_instrumentation_data;
 }
 
-thread_local bool lldb_private::repro::Recorder::g_global_boundary = false;
 std::atomic<unsigned> lldb_private::repro::Recorder::g_sequence;
 std::mutex lldb_private::repro::Recorder::g_mutex;