[lldb] Track the API boundary using a thread_local variable.

[JDevlieghere]

Summary

The reproducers currently use a static variable to track the API boundary. This is obviously incorrect when the SB API is used concurrently. While I do not plan to support that use-case (right now), I do want to avoid us crashing. As a first step, correctly track API boundaries across multiple threads.

Before this patch SB API calls made by the embedded script interpreter would be considered "behind the API boundary" and correctly ignored. After this patch, we need to tell the reproducers to ignore the scripting thread as a "private thread".

[friss]

This LGTM. I like that it's way easier than what we have discussed offline.

lldb/include/lldb/Utility/ReproducerInstrumentation.h

#endif
   Result ReplayResult(Result &&r, bool update_boundary) {
     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; }
+
 private:
   template <typename T> friend struct replay;
   void UpdateBoundary() {
     if (m_local_boundary)
       g_global_boundary = false;
   }
 
 #ifdef LLDB_REPRO_INSTR_TRACE
#endif
 
   /// Whether this function call was the one crossing the API boundary.
   bool m_local_boundary;
 
   /// Whether the return value was recorded explicitly.
   bool m_result_recorded;
 
   /// Whether we're currently across the API boundary.
-  static bool g_global_boundary;
+  static thread_local bool g_global_boundary;
 };
 
 /// To be used as the "Runtime ID" of a constructor. It also invokes the
 /// constructor when called.
 template <typename Signature> struct construct;
 template <typename Class, typename... Args> struct construct<Class(Args...)> {
   static Class *handle(lldb_private::repro::InstrumentationData data,
                        lldb_private::repro::Recorder &recorder, Class *c,

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

 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
+#include "lldb/Utility/ReproducerInstrumentation.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatAdapters.h"
 
 #include <memory>

 void ScriptInterpreterPython::Terminate() {}
 
 ScriptInterpreterPythonImpl::Locker::Locker(
     ScriptInterpreterPythonImpl *py_interpreter, uint16_t on_entry,
     uint16_t on_leave, FileSP in, FileSP out, FileSP err)
     : ScriptInterpreterLocker(),
       m_teardown_session((on_leave & TearDownSession) == TearDownSession),
       m_python_interpreter(py_interpreter) {
+  repro::Recorder::PrivateThread();
   DoAcquireLock();
   if ((on_entry & InitSession) == InitSession) {
     if (!DoInitSession(on_entry, in, out, err)) {
       // Don't teardown the session if we didn't init it.
       m_teardown_session = false;
     }
   }
 }

lldb/source/Utility/ReproducerInstrumentation.cpp

InstrumentationData &InstrumentationData::Instance() {
   return *InstanceImpl();
 }
 
 llvm::Optional<InstrumentationData> &InstrumentationData::InstanceImpl() {
   static llvm::Optional<InstrumentationData> g_instrumentation_data;
   return g_instrumentation_data;
 }
 
-bool lldb_private::repro::Recorder::g_global_boundary;
+thread_local bool lldb_private::repro::Recorder::g_global_boundary = false;