Skip to content

Commit 26456d7

Browse files
augusto2112augusto2112
committed
[lldb] Make access to ReflectionContext thread safe
ReflectionContext can potentially be accessed by multiple threads at the same time, make accessing ReflectionContext thread safe by hiding it behind a lock. rdar://112207497
1 parent ff31b9e commit 26456d7

File tree

3 files changed

+126
-95
lines changed

3 files changed

+126
-95
lines changed

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

Lines changed: 79 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -447,11 +447,45 @@ static bool HasReflectionInfo(ObjectFile *obj_file) {
447447
return hasReflectionSection;
448448
}
449449

450-
SwiftLanguageRuntimeImpl::ReflectionContextInterface *
450+
SwiftLanguageRuntimeImpl::ThreadSafeReflectionContext
451451
SwiftLanguageRuntimeImpl::GetReflectionContext() {
452-
if (!m_initialized_reflection_ctx)
453-
SetupReflection();
454-
return m_reflection_ctx.get();
452+
m_reflection_ctx_mutex.lock();
453+
SetupReflection();
454+
// SetupReflection can potentially fail.
455+
if (m_initialized_reflection_ctx)
456+
ProcessModulesToAdd();
457+
return {m_reflection_ctx.get(), m_reflection_ctx_mutex};
458+
}
459+
460+
void SwiftLanguageRuntimeImpl::ProcessModulesToAdd() {
461+
// A snapshot of the modules to be processed. This is necessary because
462+
// AddModuleToReflectionContext may recursively call into this function again.
463+
ModuleList modules_to_add_snapshot;
464+
{
465+
std::lock_guard<std::recursive_mutex> lock(m_modules_to_add.GetMutex());
466+
modules_to_add_snapshot = m_modules_to_add;
467+
m_modules_to_add.Clear();
468+
}
469+
470+
if (modules_to_add_snapshot.IsEmpty())
471+
return;
472+
473+
auto &target = m_process.GetTarget();
474+
auto exe_module = target.GetExecutableModule();
475+
Progress progress(
476+
llvm::formatv("Setting up Swift reflection for '{0}'",
477+
exe_module->GetFileSpec().GetFilename().AsCString()),
478+
modules_to_add_snapshot.GetSize());
479+
480+
size_t completion = 0;
481+
482+
// Add all defered modules to reflection context that were added to
483+
// the target since this SwiftLanguageRuntime was created.
484+
modules_to_add_snapshot.ForEach([&](const ModuleSP &module_sp) -> bool {
485+
AddModuleToReflectionContext(module_sp);
486+
progress.Increment(++completion);
487+
return true;
488+
});
455489
}
456490

457491
SwiftMetadataCache *
@@ -463,79 +497,53 @@ SwiftLanguageRuntimeImpl::GetSwiftMetadataCache() {
463497

464498
void SwiftLanguageRuntimeImpl::SetupReflection() {
465499
LLDB_SCOPED_TIMER();
466-
467-
// SetupABIBit() iterates of the Target's images and thus needs to
468-
// acquire that ModuleList's lock. We need to acquire this before
469-
// locking m_add_module_mutex, since ModulesDidLoad can also be
470-
// called from a place where that lock is already held:
471-
// + lldb_private::DynamicLoaderDarwin::AddModulesUsingImageInfos()
472-
// + lldb_private::ModuleList::AppendIfNeeded()
473-
// + lldb_private::Target::NotifyModuleAdded()
474-
// + lldb_private::Target::ModulesDidLoad()
475500

501+
502+
std::lock_guard<std::recursive_mutex> lock(m_reflection_ctx_mutex);
503+
if (m_initialized_reflection_ctx)
504+
return;
505+
476506
// The global ABI bit is read by the Swift runtime library.
477507
SetupABIBit();
478508

479-
// A copy of the modules that should be added, to prevent mutating the list
480-
// while iterating over it.
481-
ModuleList modules_snapshot;
482-
483509
auto &target = m_process.GetTarget();
484510
auto exe_module = target.GetExecutableModule();
485-
{
486-
std::lock_guard<std::recursive_mutex> lock(m_add_module_mutex);
487-
if (m_initialized_reflection_ctx)
488-
return;
489-
490-
if (!exe_module) {
491-
LLDB_LOGF(GetLog(LLDBLog::Types), "%s: Failed to get executable module",
492-
LLVM_PRETTY_FUNCTION);
493-
m_initialized_reflection_ctx = false;
494-
return;
495-
}
496511

497-
bool objc_interop = (bool)findRuntime(m_process, RuntimeKind::ObjC);
498-
const char *objc_interop_msg =
499-
objc_interop ? "with Objective-C interopability" : "Swift only";
500-
501-
auto &triple = exe_module->GetArchitecture().GetTriple();
502-
if (triple.isArch64Bit()) {
503-
LLDB_LOGF(GetLog(LLDBLog::Types),
504-
"Initializing a 64-bit reflection context (%s) for \"%s\"",
505-
triple.str().c_str(), objc_interop_msg);
506-
m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext64(
507-
this->GetMemoryReader(), objc_interop, GetSwiftMetadataCache());
508-
} else if (triple.isArch32Bit()) {
509-
LLDB_LOGF(GetLog(LLDBLog::Types),
510-
"Initializing a 32-bit reflection context (%s) for \"%s\"",
511-
triple.str().c_str(), objc_interop_msg);
512-
m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext32(
513-
this->GetMemoryReader(), objc_interop, GetSwiftMetadataCache());
514-
} else {
515-
LLDB_LOGF(GetLog(LLDBLog::Types),
516-
"Could not initialize reflection context for \"%s\"",
517-
triple.str().c_str());
518-
}
519-
520-
modules_snapshot = std::move(m_modules_to_add);
521-
m_modules_to_add.Clear();
522-
m_initialized_reflection_ctx = true;
512+
auto *log = GetLog(LLDBLog::Types);
513+
if (!exe_module) {
514+
LLDB_LOGF(log, "%s: Failed to get executable module",
515+
LLVM_PRETTY_FUNCTION);
516+
m_initialized_reflection_ctx = false;
517+
return;
523518
}
524519

525-
Progress progress(
526-
llvm::formatv("Setting up Swift reflection for '{0}'",
527-
exe_module->GetFileSpec().GetFilename().AsCString()),
528-
modules_snapshot.GetSize());
529-
530-
size_t completion = 0;
531-
532-
// Add all defered modules to reflection context that were added to
533-
// the target since this SwiftLanguageRuntime was created.
534-
modules_snapshot.ForEach([&](const ModuleSP &module_sp) -> bool {
535-
AddModuleToReflectionContext(module_sp);
536-
progress.Increment(++completion);
537-
return true;
538-
});
520+
bool objc_interop = (bool)findRuntime(m_process, RuntimeKind::ObjC);
521+
const char *objc_interop_msg =
522+
objc_interop ? "with Objective-C interopability" : "Swift only";
523+
524+
auto &triple = exe_module->GetArchitecture().GetTriple();
525+
if (triple.isArch64Bit()) {
526+
LLDB_LOGF(log, "Initializing a 64-bit reflection context (%s) for \"%s\"",
527+
triple.str().c_str(), objc_interop_msg);
528+
m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext64(
529+
this->GetMemoryReader(), objc_interop, GetSwiftMetadataCache());
530+
} else if (triple.isArch32Bit()) {
531+
LLDB_LOGF(log,
532+
"Initializing a 32-bit reflection context (%s) for \"%s\"",
533+
triple.str().c_str(), objc_interop_msg);
534+
m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext32(
535+
this->GetMemoryReader(), objc_interop, GetSwiftMetadataCache());
536+
} else {
537+
LLDB_LOGF(log,
538+
"Could not initialize reflection context for \"%s\"",
539+
triple.str().c_str());
540+
}
541+
// We set m_initialized_reflection_ctx to true here because
542+
// AddModuleToReflectionContext can potentially call into SetupReflection
543+
// again (which will early exit). This is safe to do since every other thread
544+
// using reflection context will have to wait until all the modules are added,
545+
// since the thread performing the initialization locked the mutex.
546+
m_initialized_reflection_ctx = true;
539547
}
540548

541549
bool SwiftLanguageRuntimeImpl::IsABIStable() {
@@ -922,17 +930,9 @@ bool SwiftLanguageRuntimeImpl::AddModuleToReflectionContext(
922930
}
923931

924932
void SwiftLanguageRuntimeImpl::ModulesDidLoad(const ModuleList &module_list) {
925-
// If the reflection context hasn't been initialized, add them to
926-
// the list of deferred modules so they are added in
927-
// SetupReflection(), otherwise add them directly.
928-
std::lock_guard<std::recursive_mutex> lock(m_add_module_mutex);
929-
if (!m_initialized_reflection_ctx)
930-
m_modules_to_add.AppendIfNeeded(module_list);
931-
else
932-
module_list.ForEach([&](const ModuleSP &module_sp) -> bool {
933-
AddModuleToReflectionContext(module_sp);
934-
return true;
935-
});
933+
// The modules will be lazily processed on the next call to
934+
// GetReflectionContext.
935+
m_modules_to_add.AppendIfNeeded(module_list);
936936
}
937937

938938
std::string

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

Lines changed: 14 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -453,7 +453,8 @@ SwiftLanguageRuntimeImpl::GetMemoryReader() {
453453
if (!m_memory_reader_sp) {
454454
m_memory_reader_sp.reset(new LLDBMemoryReader(
455455
m_process, [&](swift::remote::RemoteAbsolutePointer pointer) {
456-
auto *reflection_context = GetReflectionContext();
456+
ThreadSafeReflectionContext reflection_context =
457+
GetReflectionContext();
457458
return reflection_context->stripSignedPointer(pointer);
458459
}));
459460
}
@@ -1104,7 +1105,7 @@ SwiftLanguageRuntimeImpl::GetNumChildren(CompilerType type,
11041105
if (!tr)
11051106
return {};
11061107

1107-
auto *reflection_ctx = GetReflectionContext();
1108+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
11081109
auto &builder = reflection_ctx->getBuilder();
11091110
auto tc = swift::reflection::TypeConverter(builder);
11101111
LLDBTypeInfoProvider tip(*this, *ts);
@@ -1331,7 +1332,7 @@ SwiftLanguageRuntimeImpl::GetIndexOfChildMemberWithName(
13311332
exe_ctx, omit_empty_base_classes,
13321333
child_indexes);
13331334
case ReferenceKind::Strong: {
1334-
auto *reflection_ctx = GetReflectionContext();
1335+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
13351336
auto &builder = reflection_ctx->getBuilder();
13361337
TypeConverter tc(builder);
13371338
LLDBTypeInfoProvider tip(*this, *ts);
@@ -1511,7 +1512,7 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
15111512
llvm::StringRef type_name = TypeSystemSwiftTypeRef::GetBaseName(
15121513
ts->CanonicalizeSugar(dem, type_node));
15131514

1514-
auto *reflection_ctx = GetReflectionContext();
1515+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
15151516
if (!reflection_ctx)
15161517
return {};
15171518
CompilerType instance_type = valobj->GetCompilerType();
@@ -1625,7 +1626,7 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
16251626

16261627
bool SwiftLanguageRuntimeImpl::ForEachSuperClassType(
16271628
ValueObject &instance, std::function<bool(SuperClassType)> fn) {
1628-
auto *reflection_ctx = GetReflectionContext();
1629+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
16291630
if (!reflection_ctx)
16301631
return false;
16311632
CompilerType instance_type = instance.GetCompilerType();
@@ -1692,7 +1693,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Pack(
16921693
lldb::DynamicValueType use_dynamic, TypeAndOrName &pack_type_or_name,
16931694
Address &address, Value::ValueType &value_type) {
16941695
Log *log(GetLog(LLDBLog::Types));
1695-
auto *reflection_ctx = GetReflectionContext();
1696+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
16961697
if (!reflection_ctx)
16971698
return false;
16981699

@@ -2011,7 +2012,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Class(
20112012
return false;
20122013
}
20132014
Log *log(GetLog(LLDBLog::Types));
2014-
auto *reflection_ctx = GetReflectionContext();
2015+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
20152016
const auto *typeref = reflection_ctx->readTypeFromInstance(instance_ptr);
20162017
if (!typeref) {
20172018
LLDB_LOGF(log,
@@ -2234,7 +2235,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Protocol(
22342235

22352236
swift::remote::RemoteAddress remote_existential(existential_address);
22362237

2237-
auto *reflection_ctx = GetReflectionContext();
2238+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
22382239
auto pair = reflection_ctx->projectExistentialAndUnwrapClass(
22392240
remote_existential, *protocol_typeref);
22402241
if (use_local_buffer)
@@ -2365,7 +2366,7 @@ CompilerType SwiftLanguageRuntimeImpl::BindGenericTypeParameters(
23652366
auto ts =
23662367
unbound_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
23672368
Status error;
2368-
auto *reflection_ctx = GetReflectionContext();
2369+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
23692370
if (!reflection_ctx) {
23702371
LLDB_LOG(GetLog(LLDBLog::Types),
23712372
"No reflection context available.");
@@ -2433,7 +2434,7 @@ SwiftLanguageRuntimeImpl::BindGenericTypeParameters(StackFrame &stack_frame,
24332434
using namespace swift::Demangle;
24342435

24352436
Status error;
2436-
auto *reflection_ctx = GetReflectionContext();
2437+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
24372438
if (!reflection_ctx) {
24382439
LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types),
24392440
"No reflection context available.");
@@ -2893,7 +2894,7 @@ SwiftLanguageRuntimeImpl::GetValueType(ValueObject &in_value,
28932894
// Read the value witness table and check if the data is inlined in
28942895
// the existential container or not.
28952896
swift::remote::RemoteAddress remote_existential(existential_address);
2896-
auto *reflection_ctx = GetReflectionContext();
2897+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
28972898
llvm::Optional<bool> is_inlined =
28982899
reflection_ctx->isValueInlinedInExistentialContainer(
28992900
remote_existential);
@@ -3372,7 +3373,7 @@ SwiftLanguageRuntimeImpl::GetTypeRef(CompilerType type,
33723373
return nullptr;
33733374

33743375
// Build a TypeRef.
3375-
auto *reflection_ctx = GetReflectionContext();
3376+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
33763377
if (!reflection_ctx)
33773378
return nullptr;
33783379

@@ -3447,7 +3448,7 @@ SwiftLanguageRuntimeImpl::GetSwiftRuntimeTypeInfo(
34473448
if (out_tr)
34483449
*out_tr = type_ref;
34493450

3450-
auto *reflection_ctx = GetReflectionContext();
3451+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
34513452
if (!reflection_ctx)
34523453
return nullptr;
34533454

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

Lines changed: 33 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -256,6 +256,29 @@ class SwiftLanguageRuntimeImpl {
256256
stripSignedPointer(swift::remote::RemoteAbsolutePointer pointer) = 0;
257257
};
258258

259+
/// A wrapper around TargetReflectionContext, which holds a lock to ensure
260+
/// exclusive access.
261+
struct ThreadSafeReflectionContext {
262+
ThreadSafeReflectionContext(ReflectionContextInterface *reflection_ctx,
263+
std::recursive_mutex &mutex)
264+
: m_reflection_ctx(reflection_ctx), m_lock(mutex, std::adopt_lock) {}
265+
266+
ReflectionContextInterface *operator->() const {
267+
return m_reflection_ctx;
268+
}
269+
270+
operator bool() const {
271+
return m_reflection_ctx != nullptr;
272+
}
273+
274+
private:
275+
ReflectionContextInterface *m_reflection_ctx;
276+
// This lock operates on a recursive mutex because the initialization
277+
// of ReflectionContext recursive calls itself (see
278+
// SwiftLanguageRuntimeImpl::SetupReflection).
279+
std::lock_guard<std::recursive_mutex> m_lock;
280+
};
281+
259282
protected:
260283
static void
261284
ForEachGenericParameter(swift::Demangle::NodePointer node,
@@ -384,8 +407,13 @@ class SwiftLanguageRuntimeImpl {
384407
/// Lazily initialize and return \p m_dynamic_exclusivity_flag_addr.
385408
llvm::Optional<lldb::addr_t> GetDynamicExclusivityFlagAddr();
386409

387-
/// Lazily initialize the reflection context. Return \p nullptr on failure.
388-
ReflectionContextInterface *GetReflectionContext();
410+
/// Lazily initialize the reflection context. Returns a
411+
/// ThreadSafeReflectionContext with a \p nullptr on failure.
412+
ThreadSafeReflectionContext GetReflectionContext();
413+
414+
// Add the modules in m_modules_to_add to the Reflection Context. The
415+
// ModulesDidLoad() callback appends to m_modules_to_add.
416+
void ProcessModulesToAdd();
389417

390418
/// Lazily initialize and return \p m_SwiftNativeNSErrorISA.
391419
llvm::Optional<lldb::addr_t> GetSwiftNativeNSErrorISA();
@@ -409,12 +437,14 @@ class SwiftLanguageRuntimeImpl {
409437
/// \{
410438
std::unique_ptr<ReflectionContextInterface> m_reflection_ctx;
411439

440+
/// Mutex guarding accesses to the reflection context.
441+
std::recursive_mutex m_reflection_ctx_mutex;
442+
412443
SwiftMetadataCache m_swift_metadata_cache;
413444

414445
/// Record modules added through ModulesDidLoad, which are to be
415446
/// added to the reflection context once it's being initialized.
416447
ModuleList m_modules_to_add;
417-
std::recursive_mutex m_add_module_mutex;
418448

419449
/// Add the image to the reflection context.
420450
/// \return true on success.

0 commit comments

Comments
 (0)