Merge commit 'db8c62e598e7' from swift/release/5.9 into stable/20221013

Author: git apple-llvm automerger

lldb/include/lldb/Core/ModuleList.h

@@ -500,6 +500,9 @@ class ModuleList {
   bool AnyOf(
       std::function<bool(lldb_private::Module &module)> const &callback) const;
 
+  /// Atomically swaps the contents of this module list with \a other.
+  void Swap(ModuleList &other);
+
 protected:
   // Class typedefs.
   typedef std::vector<lldb::ModuleSP>

lldb/source/Core/ModuleList.cpp

@@ -1295,3 +1295,10 @@ bool ModuleList::AnyOf(
 
   return false;
 }
+
+
+void ModuleList::Swap(ModuleList &other) {
+  // scoped_lock locks both mutexes at once.
+  std::scoped_lock lock(m_modules_mutex, other.m_modules_mutex);
+  m_modules.swap(other.m_modules);
+}

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp

@@ -447,11 +447,41 @@ static bool HasReflectionInfo(ObjectFile *obj_file) {
   return hasReflectionSection;
 }
 
-SwiftLanguageRuntimeImpl::ReflectionContextInterface *
+SwiftLanguageRuntimeImpl::ThreadSafeReflectionContext 
 SwiftLanguageRuntimeImpl::GetReflectionContext() {
-  if (!m_initialized_reflection_ctx)
-    SetupReflection();
-  return m_reflection_ctx.get();
+  m_reflection_ctx_mutex.lock();
+  SetupReflection();
+  // SetupReflection can potentially fail.
+  if (m_initialized_reflection_ctx)
+    ProcessModulesToAdd();
+  return {m_reflection_ctx.get(), m_reflection_ctx_mutex};
+}
+
+void SwiftLanguageRuntimeImpl::ProcessModulesToAdd() {
+  // A snapshot of the modules to be processed. This is necessary because
+  // AddModuleToReflectionContext may recursively call into this function again.
+  ModuleList modules_to_add_snapshot;
+  modules_to_add_snapshot.Swap(m_modules_to_add);
+
+  if (modules_to_add_snapshot.IsEmpty())
+    return;
+
+  auto &target = m_process.GetTarget();
+  auto exe_module = target.GetExecutableModule();
+  Progress progress(
+      llvm::formatv("Setting up Swift reflection for '{0}'",
+                    exe_module->GetFileSpec().GetFilename().AsCString()),
+      modules_to_add_snapshot.GetSize());
+
+  size_t completion = 0;
+
+  // Add all defered modules to reflection context that were added to
+  // the target since this SwiftLanguageRuntime was created.
+  modules_to_add_snapshot.ForEach([&](const ModuleSP &module_sp) -> bool {
+    AddModuleToReflectionContext(module_sp);
+    progress.Increment(++completion);
+    return true;
+  });
 }
 
 SwiftMetadataCache *
@@ -463,79 +493,53 @@ SwiftLanguageRuntimeImpl::GetSwiftMetadataCache() {
 
 void SwiftLanguageRuntimeImpl::SetupReflection() {
   LLDB_SCOPED_TIMER();
- 
-  // SetupABIBit() iterates of the Target's images and thus needs to
-  // acquire that ModuleList's lock. We need to acquire this before
-  // locking m_add_module_mutex, since ModulesDidLoad can also be
-  // called from a place where that lock is already held:
-  // +   lldb_private::DynamicLoaderDarwin::AddModulesUsingImageInfos()
-  // +     lldb_private::ModuleList::AppendIfNeeded()
-  // +       lldb_private::Target::NotifyModuleAdded()
-  // +         lldb_private::Target::ModulesDidLoad()
 
+
+  std::lock_guard<std::recursive_mutex> lock(m_reflection_ctx_mutex);
+  if (m_initialized_reflection_ctx)
+    return;
+ 
   // The global ABI bit is read by the Swift runtime library.
   SetupABIBit();
 
-  // A copy of the modules that should be added, to prevent mutating the list
-  // while iterating over it.
-  ModuleList modules_snapshot;
-
   auto &target = m_process.GetTarget();
   auto exe_module = target.GetExecutableModule();
-  {
-    std::lock_guard<std::recursive_mutex> lock(m_add_module_mutex);
-    if (m_initialized_reflection_ctx)
-      return;
-
-    if (!exe_module) {
-      LLDB_LOGF(GetLog(LLDBLog::Types), "%s: Failed to get executable module",
-                LLVM_PRETTY_FUNCTION);
-      m_initialized_reflection_ctx = false;
-      return;
-    }
 
-    bool objc_interop = (bool)findRuntime(m_process, RuntimeKind::ObjC);
-    const char *objc_interop_msg =
-        objc_interop ? "with Objective-C interopability" : "Swift only";
-
-    auto &triple = exe_module->GetArchitecture().GetTriple();
-    if (triple.isArch64Bit()) {
-      LLDB_LOGF(GetLog(LLDBLog::Types),
-                "Initializing a 64-bit reflection context (%s) for \"%s\"",
-                triple.str().c_str(), objc_interop_msg);
-      m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext64(
-          this->GetMemoryReader(), objc_interop, GetSwiftMetadataCache());
-    } else if (triple.isArch32Bit()) {
-      LLDB_LOGF(GetLog(LLDBLog::Types),
-                "Initializing a 32-bit reflection context (%s) for \"%s\"",
-                triple.str().c_str(), objc_interop_msg);
-      m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext32(
-          this->GetMemoryReader(), objc_interop, GetSwiftMetadataCache());
-    } else {
-      LLDB_LOGF(GetLog(LLDBLog::Types),
-                "Could not initialize reflection context for \"%s\"",
-                triple.str().c_str());
-    }
-
-    modules_snapshot = std::move(m_modules_to_add);
-    m_modules_to_add.Clear();
-    m_initialized_reflection_ctx = true;
+  auto *log = GetLog(LLDBLog::Types);
+  if (!exe_module) {
+    LLDB_LOGF(log, "%s: Failed to get executable module",
+              LLVM_PRETTY_FUNCTION);
+    m_initialized_reflection_ctx = false;
+    return;
   }
 
-  Progress progress(
-      llvm::formatv("Setting up Swift reflection for '{0}'",
-                    exe_module->GetFileSpec().GetFilename().AsCString()),
-      modules_snapshot.GetSize());
-
-  size_t completion = 0;
-
-  // Add all defered modules to reflection context that were added to
-  // the target since this SwiftLanguageRuntime was created.
-  modules_snapshot.ForEach([&](const ModuleSP &module_sp) -> bool {
-    AddModuleToReflectionContext(module_sp);
-    progress.Increment(++completion);
-    return true;
-  });
+  bool objc_interop = (bool)findRuntime(m_process, RuntimeKind::ObjC);
+  const char *objc_interop_msg =
+      objc_interop ? "with Objective-C interopability" : "Swift only";
+
+  auto &triple = exe_module->GetArchitecture().GetTriple();
+  if (triple.isArch64Bit()) {
+    LLDB_LOGF(log, "Initializing a 64-bit reflection context (%s) for \"%s\"",
+              triple.str().c_str(), objc_interop_msg);
+    m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext64(
+        this->GetMemoryReader(), objc_interop, GetSwiftMetadataCache());
+  } else if (triple.isArch32Bit()) {
+    LLDB_LOGF(log,
+              "Initializing a 32-bit reflection context (%s) for \"%s\"",
+              triple.str().c_str(), objc_interop_msg);
+    m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext32(
+        this->GetMemoryReader(), objc_interop, GetSwiftMetadataCache());
+  } else {
+    LLDB_LOGF(log,
+              "Could not initialize reflection context for \"%s\"",
+              triple.str().c_str());
+  }
+  // We set m_initialized_reflection_ctx to true here because
+  // AddModuleToReflectionContext can potentially call into SetupReflection
+  // again (which will early exit). This is safe to do since every other thread
+  // using reflection context will have to wait until all the modules are added,
+  // since the thread performing the initialization locked the mutex.
+  m_initialized_reflection_ctx = true;
 }
 
 bool SwiftLanguageRuntimeImpl::IsABIStable() {
@@ -922,17 +926,9 @@ bool SwiftLanguageRuntimeImpl::AddModuleToReflectionContext(
 }
 
 void SwiftLanguageRuntimeImpl::ModulesDidLoad(const ModuleList &module_list) {
-  // If the reflection context hasn't been initialized, add them to
-  // the list of deferred modules so they are added in
-  // SetupReflection(), otherwise add them directly.
-  std::lock_guard<std::recursive_mutex> lock(m_add_module_mutex);
-  if (!m_initialized_reflection_ctx)
-    m_modules_to_add.AppendIfNeeded(module_list);
-  else
-    module_list.ForEach([&](const ModuleSP &module_sp) -> bool {
-      AddModuleToReflectionContext(module_sp);
-      return true;
-    });
+  // The modules will be lazily processed on the next call to
+  // GetReflectionContext.
+  m_modules_to_add.AppendIfNeeded(module_list);
 }
 
 std::string 

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -453,7 +453,8 @@ SwiftLanguageRuntimeImpl::GetMemoryReader() {
   if (!m_memory_reader_sp) {
     m_memory_reader_sp.reset(new LLDBMemoryReader(
         m_process, [&](swift::remote::RemoteAbsolutePointer pointer) {
-          auto *reflection_context = GetReflectionContext();
+          ThreadSafeReflectionContext reflection_context =
+              GetReflectionContext();
           return reflection_context->stripSignedPointer(pointer);
         }));
   }
@@ -1104,7 +1105,7 @@ SwiftLanguageRuntimeImpl::GetNumChildren(CompilerType type,
     if (!tr)
       return {};
 
-    auto *reflection_ctx = GetReflectionContext();
+    ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
     auto &builder = reflection_ctx->getBuilder();
     auto tc = swift::reflection::TypeConverter(builder);
     LLDBTypeInfoProvider tip(*this, *ts);
@@ -1311,7 +1312,7 @@ SwiftLanguageRuntimeImpl::GetIndexOfChildMemberWithName(
                                            exe_ctx, omit_empty_base_classes,
                                            child_indexes);
     case ReferenceKind::Strong: {
-      auto *reflection_ctx = GetReflectionContext();
+      ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
       auto &builder = reflection_ctx->getBuilder();
       TypeConverter tc(builder);
       LLDBTypeInfoProvider tip(*this, *ts);
@@ -1491,7 +1492,7 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
     llvm::StringRef type_name = TypeSystemSwiftTypeRef::GetBaseName(
         ts->CanonicalizeSugar(dem, type_node));
 
-    auto *reflection_ctx = GetReflectionContext();
+    ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
     if (!reflection_ctx)
       return {};
     CompilerType instance_type = valobj->GetCompilerType();
@@ -1605,7 +1606,7 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
 
 bool SwiftLanguageRuntimeImpl::ForEachSuperClassType(
     ValueObject &instance, std::function<bool(SuperClassType)> fn) {
-  auto *reflection_ctx = GetReflectionContext();
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
   if (!reflection_ctx)
     return false;
   CompilerType instance_type = instance.GetCompilerType();
@@ -1672,7 +1673,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Pack(
     lldb::DynamicValueType use_dynamic, TypeAndOrName &pack_type_or_name,
     Address &address, Value::ValueType &value_type) {
   Log *log(GetLog(LLDBLog::Types));
-  auto *reflection_ctx = GetReflectionContext();
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
   if (!reflection_ctx)
     return false;
 
@@ -1993,7 +1994,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Class(
       return false;
     }
   Log *log(GetLog(LLDBLog::Types));
-  auto *reflection_ctx = GetReflectionContext();
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
   const auto *typeref = reflection_ctx->readTypeFromInstance(instance_ptr);
   if (!typeref) {
     LLDB_LOGF(log,
@@ -2216,7 +2217,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Protocol(
 
   swift::remote::RemoteAddress remote_existential(existential_address);
 
-  auto *reflection_ctx = GetReflectionContext();
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
   auto pair = reflection_ctx->projectExistentialAndUnwrapClass(
       remote_existential, *protocol_typeref);
   if (use_local_buffer)
@@ -2347,7 +2348,7 @@ CompilerType SwiftLanguageRuntimeImpl::BindGenericTypeParameters(
   auto ts =
       unbound_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
   Status error;
-  auto *reflection_ctx = GetReflectionContext();
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
   if (!reflection_ctx) {
     LLDB_LOG(GetLog(LLDBLog::Types),
              "No reflection context available.");
@@ -2415,7 +2416,7 @@ SwiftLanguageRuntimeImpl::BindGenericTypeParameters(StackFrame &stack_frame,
   using namespace swift::Demangle;
 
   Status error;
-  auto *reflection_ctx = GetReflectionContext();
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
   if (!reflection_ctx) {
     LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types),
              "No reflection context available.");
@@ -2875,7 +2876,7 @@ SwiftLanguageRuntimeImpl::GetValueType(ValueObject &in_value,
       // Read the value witness table and check if the data is inlined in
       // the existential container or not.
       swift::remote::RemoteAddress remote_existential(existential_address);
-      auto *reflection_ctx = GetReflectionContext();
+      ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
       llvm::Optional<bool> is_inlined =
           reflection_ctx->isValueInlinedInExistentialContainer(
               remote_existential);
@@ -3354,7 +3355,7 @@ SwiftLanguageRuntimeImpl::GetTypeRef(CompilerType type,
     return nullptr;
 
   // Build a TypeRef.
-  auto *reflection_ctx = GetReflectionContext();
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
   if (!reflection_ctx)
     return nullptr;
 
@@ -3429,7 +3430,7 @@ SwiftLanguageRuntimeImpl::GetSwiftRuntimeTypeInfo(
   if (out_tr)
     *out_tr = type_ref;
 
-  auto *reflection_ctx = GetReflectionContext();
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
   if (!reflection_ctx)
     return nullptr;
 

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeImpl.h

@@ -256,6 +256,29 @@ class SwiftLanguageRuntimeImpl {
     stripSignedPointer(swift::remote::RemoteAbsolutePointer pointer) = 0;
   };
 
+  /// A wrapper around TargetReflectionContext, which holds a lock to ensure
+  /// exclusive access.
+  struct ThreadSafeReflectionContext {
+    ThreadSafeReflectionContext(ReflectionContextInterface *reflection_ctx,
+                             std::recursive_mutex &mutex)
+        : m_reflection_ctx(reflection_ctx), m_lock(mutex, std::adopt_lock) {}
+
+    ReflectionContextInterface *operator->() const {
+      return m_reflection_ctx;
+    }
+
+    operator bool() const {
+      return m_reflection_ctx != nullptr;
+    }
+
+  private:
+    ReflectionContextInterface *m_reflection_ctx;
+    // This lock operates on a recursive mutex because the initialization
+    // of ReflectionContext recursive calls itself (see
+    // SwiftLanguageRuntimeImpl::SetupReflection).
+    std::lock_guard<std::recursive_mutex> m_lock;
+  };
+
 protected:
   static void
   ForEachGenericParameter(swift::Demangle::NodePointer node,
@@ -384,8 +407,13 @@ class SwiftLanguageRuntimeImpl {
   /// Lazily initialize and return \p m_dynamic_exclusivity_flag_addr.
   llvm::Optional<lldb::addr_t> GetDynamicExclusivityFlagAddr();
 
-  /// Lazily initialize the reflection context. Return \p nullptr on failure.
-  ReflectionContextInterface *GetReflectionContext();
+  /// Lazily initialize the reflection context. Returns a
+  /// ThreadSafeReflectionContext with a \p nullptr on failure.
+  ThreadSafeReflectionContext GetReflectionContext();
+
+  // Add the modules in m_modules_to_add to the Reflection Context. The
+  // ModulesDidLoad() callback appends to m_modules_to_add.
+  void ProcessModulesToAdd();
 
   /// Lazily initialize and return \p m_SwiftNativeNSErrorISA.
   llvm::Optional<lldb::addr_t> GetSwiftNativeNSErrorISA();
@@ -409,12 +437,14 @@ class SwiftLanguageRuntimeImpl {
   /// \{
   std::unique_ptr<ReflectionContextInterface> m_reflection_ctx;
 
+  /// Mutex guarding accesses to the reflection context.
+  std::recursive_mutex m_reflection_ctx_mutex;
+
   SwiftMetadataCache m_swift_metadata_cache;
 
   /// Record modules added through ModulesDidLoad, which are to be
   /// added to the reflection context once it's being initialized.
   ModuleList m_modules_to_add;
-  std::recursive_mutex m_add_module_mutex;
 
   /// Add the image to the reflection context.
   /// \return true on success.