From 6eaedbb52f2a616e644e5acc7279c8b07c4cfe82 Mon Sep 17 00:00:00 2001 From: Adrian Prantl Date: Mon, 14 Nov 2022 16:24:36 -0800 Subject: 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. Most of the std::weak_ptr* 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 --- lldb/source/API/SBModule.cpp | 44 +++++++++++++++++++++++--------------------- 1 file changed, 23 insertions(+), 21 deletions(-) (limited to 'lldb/source/API/SBModule.cpp') diff --git a/lldb/source/API/SBModule.cpp b/lldb/source/API/SBModule.cpp index c4e876eb15de..e7c2b451eb9d 100644 --- a/lldb/source/API/SBModule.cpp +++ b/lldb/source/API/SBModule.cpp @@ -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++) { -- cgit v1.2.3