Make CompilerType safe

When a process gets restarted TypeSystem objects associated with it
may get deleted, and any CompilerType objects holding on to a
reference to that type system are a use-after-free in waiting. Because
of the SBAPI, we don't have tight control over where CompilerTypes go
and when they are used. This is particularly a problem in the Swift
plugin, where the scratch TypeSystem can be restarted while the
process is still running. The Swift plugin has a lock to prevent
abuse, but where there's a lock there can be bugs.

This patch changes CompilerType to store a std::weak_ptr<TypeSystem>.
Most of the std::weak_ptr<TypeSystem>* uglyness is hidden by
introducing a wrapper class CompilerType::WrappedTypeSystem that has a
dyn_cast_or_null() method. The only sites that need to know about the
weak pointer implementation detail are the ones that deal with
creating TypeSystems.

rdar://101505232

Differential Revision: https://reviews.llvm.org/D136650
This commit is contained in:
Adrian Prantl committed 2022-11-16 15:51:26 -08:00
1 parent 0fcb26c5b6
commit 6eaedbb52f
83 files changed
+1052 -662

No files matched your search

+23 -21
View File
@@ -436,26 +436,28 @@ lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
LLDB_INSTRUMENT_VA(this, name_cstr);
SBType sb_type;
ModuleSP module_sp(GetSP());
if (name_cstr && module_sp) {
SymbolContext sc;
const bool exact_match = false;
ConstString name(name_cstr);
if (!name_cstr || !module_sp)
return {};
SymbolContext sc;
const bool exact_match = false;
ConstString name(name_cstr);
sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match));
SBType sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match));
if (!sb_type.IsValid()) {
auto type_system_or_err =
module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
llvm::consumeError(std::move(err));
return SBType();
}
sb_type = SBType(type_system_or_err->GetBuiltinTypeByName(name));
}
if (sb_type.IsValid())
return sb_type;
auto type_system_or_err = module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
llvm::consumeError(std::move(err));
return {};
}
return sb_type;
if (auto ts = *type_system_or_err)
return SBType(ts->GetBuiltinTypeByName(name));
return {};
}
lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
@@ -468,7 +470,8 @@ lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
if (auto err = type_system_or_err.takeError()) {
llvm::consumeError(std::move(err));
} else {
return SBType(type_system_or_err->GetBasicTypeFromAST(type));
if (auto ts = *type_system_or_err)
return SBType(ts->GetBasicTypeFromAST(type));
}
}
return SBType();
@@ -494,10 +497,9 @@ lldb::SBTypeList SBModule::FindTypes(const char *type) {
if (auto err = type_system_or_err.takeError()) {
llvm::consumeError(std::move(err));
} else {
CompilerType compiler_type =
type_system_or_err->GetBuiltinTypeByName(name);
if (compiler_type)
retval.Append(SBType(compiler_type));
if (auto ts = *type_system_or_err)
if (CompilerType compiler_type = ts->GetBuiltinTypeByName(name))
retval.Append(SBType(compiler_type));
}
} else {
for (size_t idx = 0; idx < type_list.GetSize(); idx++) {