diff options
36 files changed, 596 insertions, 328 deletions
diff --git a/include/lldb/Core/Module.h b/include/lldb/Core/Module.h index 19bcbd6e8..daf61a758 100644 --- a/include/lldb/Core/Module.h +++ b/include/lldb/Core/Module.h @@ -812,7 +812,8 @@ public: bool GetIsDynamicLinkEditor(); - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language); + llvm::Expected<TypeSystem &> + GetTypeSystemForLanguage(lldb::LanguageType language); // Special error functions that can do printf style formatting that will // prepend the message with something appropriate for this module (like the diff --git a/include/lldb/Symbol/SymbolFile.h b/include/lldb/Symbol/SymbolFile.h index 29d561094..19d8bec19 100644 --- a/include/lldb/Symbol/SymbolFile.h +++ b/include/lldb/Symbol/SymbolFile.h @@ -201,7 +201,7 @@ public: virtual void PreloadSymbols(); - virtual lldb_private::TypeSystem * + virtual llvm::Expected<lldb_private::TypeSystem &> GetTypeSystemForLanguage(lldb::LanguageType language); virtual CompilerDeclContext diff --git a/include/lldb/Symbol/TypeSystem.h b/include/lldb/Symbol/TypeSystem.h index 4bef2a444..a0eb5f75f 100644 --- a/include/lldb/Symbol/TypeSystem.h +++ b/include/lldb/Symbol/TypeSystem.h @@ -16,6 +16,7 @@ #include "llvm/ADT/APSInt.h" #include "llvm/Support/Casting.h" +#include "llvm/Support/Error.h" #include "lldb/Core/PluginInterface.h" #include "lldb/Expression/Expression.h" @@ -491,18 +492,15 @@ public: // callback to keep iterating, false to stop iterating. void ForEach(std::function<bool(TypeSystem *)> const &callback); - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language, - Module *module, bool can_create); + llvm::Expected<TypeSystem &> + GetTypeSystemForLanguage(lldb::LanguageType language, Module *module, + bool can_create); - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language, - Target *target, bool can_create); + llvm::Expected<TypeSystem &> + GetTypeSystemForLanguage(lldb::LanguageType language, Target *target, + bool can_create); protected: - // This function does not take the map mutex, and should only be called from - // functions that do take the mutex. - void AddToMap(lldb::LanguageType language, - lldb::TypeSystemSP const &type_system_sp); - typedef std::map<lldb::LanguageType, lldb::TypeSystemSP> collection; mutable std::mutex m_mutex; ///< A mutex to keep this object happy in ///multi-threaded environments. diff --git a/include/lldb/Target/Target.h b/include/lldb/Target/Target.h index 82af2f83b..20abc8eb3 100644 --- a/include/lldb/Target/Target.h +++ b/include/lldb/Target/Target.h @@ -1022,9 +1022,9 @@ public: PathMappingList &GetImageSearchPathList(); - TypeSystem *GetScratchTypeSystemForLanguage(Status *error, - lldb::LanguageType language, - bool create_on_demand = true); + llvm::Expected<TypeSystem &> + GetScratchTypeSystemForLanguage(lldb::LanguageType language, + bool create_on_demand = true); PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language); diff --git a/source/API/SBModule.cpp b/source/API/SBModule.cpp index 4bd32bce1..e3c48cfce 100644 --- a/source/API/SBModule.cpp +++ b/source/API/SBModule.cpp @@ -468,10 +468,13 @@ lldb::SBType SBModule::FindFirstType(const char *name_cstr) { sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match)); if (!sb_type.IsValid()) { - TypeSystem *type_system = + auto type_system_or_err = module_sp->GetTypeSystemForLanguage(eLanguageTypeC); - if (type_system) - sb_type = SBType(type_system->GetBuiltinTypeByName(name)); + if (auto err = type_system_or_err.takeError()) { + llvm::consumeError(std::move(err)); + return LLDB_RECORD_RESULT(SBType()); + } + sb_type = SBType(type_system_or_err->GetBuiltinTypeByName(name)); } } return LLDB_RECORD_RESULT(sb_type); @@ -483,10 +486,14 @@ lldb::SBType SBModule::GetBasicType(lldb::BasicType type) { ModuleSP module_sp(GetSP()); if (module_sp) { - TypeSystem *type_system = + auto type_system_or_err = module_sp->GetTypeSystemForLanguage(eLanguageTypeC); - if (type_system) - return LLDB_RECORD_RESULT(SBType(type_system->GetBasicTypeFromAST(type))); + if (auto err = type_system_or_err.takeError()) { + llvm::consumeError(std::move(err)); + } else { + return LLDB_RECORD_RESULT( + SBType(type_system_or_err->GetBasicTypeFromAST(type))); + } } return LLDB_RECORD_RESULT(SBType()); } @@ -513,10 +520,13 @@ lldb::SBTypeList SBModule::FindTypes(const char *type) { retval.Append(SBType(type_sp)); } } else { - TypeSystem *type_system = + auto type_system_or_err = module_sp->GetTypeSystemForLanguage(eLanguageTypeC); - if (type_system) { - CompilerType compiler_type = type_system->GetBuiltinTypeByName(name); + 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)); } diff --git a/source/Breakpoint/Watchpoint.cpp b/source/Breakpoint/Watchpoint.cpp index 071f8fc86..17dcda13e 100644 --- a/source/Breakpoint/Watchpoint.cpp +++ b/source/Breakpoint/Watchpoint.cpp @@ -17,6 +17,7 @@ #include "lldb/Target/Process.h" #include "lldb/Target/Target.h" #include "lldb/Target/ThreadSpec.h" +#include "lldb/Utility/Log.h" #include "lldb/Utility/Stream.h" using namespace lldb; @@ -30,15 +31,22 @@ Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size, m_watch_write(0), m_watch_was_read(0), m_watch_was_written(0), m_ignore_count(0), m_false_alarms(0), m_decl_str(), m_watch_spec_str(), m_type(), m_error(), m_options(), m_being_created(true) { + if (type && type->IsValid()) m_type = *type; else { // If we don't have a known type, then we force it to unsigned int of the // right size. - TypeSystem *ast_context = - target.GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC); - m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, - 8 * size); + auto type_system_or_err = + target.GetScratchTypeSystemForLanguage(eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS), + std::move(err), "Failed to set type."); + } else { + m_type = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize( + eEncodingUint, 8 * size); + } } // Set the initial value of the watched variable: diff --git a/source/Core/Module.cpp b/source/Core/Module.cpp index 2dd0e5998..9865beabe 100644 --- a/source/Core/Module.cpp +++ b/source/Core/Module.cpp @@ -353,7 +353,8 @@ void Module::SetUUID(const lldb_private::UUID &uuid) { } } -TypeSystem *Module::GetTypeSystemForLanguage(LanguageType language) { +llvm::Expected<TypeSystem &> +Module::GetTypeSystemForLanguage(LanguageType language) { return m_type_system_map.GetTypeSystemForLanguage(language, this, true); } diff --git a/source/Core/ValueObjectRegister.cpp b/source/Core/ValueObjectRegister.cpp index 75a254fbb..7e97df6d2 100644 --- a/source/Core/ValueObjectRegister.cpp +++ b/source/Core/ValueObjectRegister.cpp @@ -18,6 +18,7 @@ #include "lldb/Target/StackFrame.h" #include "lldb/Target/Target.h" #include "lldb/Utility/DataExtractor.h" +#include "lldb/Utility/Log.h" #include "lldb/Utility/Scalar.h" #include "lldb/Utility/Status.h" #include "lldb/Utility/Stream.h" @@ -256,15 +257,19 @@ ValueObjectRegister::~ValueObjectRegister() {} CompilerType ValueObjectRegister::GetCompilerTypeImpl() { if (!m_compiler_type.IsValid()) { ExecutionContext exe_ctx(GetExecutionContextRef()); - Target *target = exe_ctx.GetTargetPtr(); - if (target) { - Module *exe_module = target->GetExecutableModulePointer(); - if (exe_module) { - TypeSystem *type_system = + if (auto *target = exe_ctx.GetTargetPtr()) { + if (auto *exe_module = target->GetExecutableModulePointer()) { + auto type_system_or_err = exe_module->GetTypeSystemForLanguage(eLanguageTypeC); - if (type_system) - m_compiler_type = type_system->GetBuiltinTypeForEncodingAndBitSize( - m_reg_info.encoding, m_reg_info.byte_size * 8); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TYPES), + std::move(err), "Unable to get CompilerType from TypeSystem"); + } else { + m_compiler_type = + type_system_or_err->GetBuiltinTypeForEncodingAndBitSize( + m_reg_info.encoding, m_reg_info.byte_size * 8); + } } } } diff --git a/source/DataFormatters/VectorType.cpp b/source/DataFormatters/VectorType.cpp index 18880f72e..26fc03a4c 100644 --- a/source/DataFormatters/VectorType.cpp +++ b/source/DataFormatters/VectorType.cpp @@ -15,6 +15,7 @@ #include "lldb/Target/Target.h" #include "lldb/Utility/LLDBAssert.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; @@ -219,13 +220,20 @@ public: CompilerType parent_type(m_backend.GetCompilerType()); CompilerType element_type; parent_type.IsVectorType(&element_type, nullptr); - TargetSP target_sp(m_backend.GetTargetSP()); - m_child_type = ::GetCompilerTypeForFormat( - m_parent_format, element_type, - target_sp - ? target_sp->GetScratchTypeSystemForLanguage(nullptr, - lldb::eLanguageTypeC) - : nullptr); + TypeSystem *type_system = nullptr; + if (auto target_sp = m_backend.GetTargetSP()) { + auto type_system_or_err = + target_sp->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS), + std::move(err), "Unable to update from scratch TypeSystem"); + } else { + type_system = &type_system_or_err.get(); + } + } + m_child_type = + ::GetCompilerTypeForFormat(m_parent_format, element_type, type_system); m_num_children = ::CalculateNumChildren(parent_type, m_child_type); m_item_format = GetItemFormatForFormat(m_parent_format, m_child_type); return false; diff --git a/source/Expression/Materializer.cpp b/source/Expression/Materializer.cpp index e86afb601..291f81e5a 100644 --- a/source/Expression/Materializer.cpp +++ b/source/Expression/Materializer.cpp @@ -869,20 +869,18 @@ public: return; } - Status type_system_error; - TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage( - &type_system_error, m_type.GetMinimumLanguage()); + auto type_system_or_err = + target_sp->GetScratchTypeSystemForLanguage(m_type.GetMinimumLanguage()); - if (!type_system) { + if (auto error = type_system_or_err.takeError()) { err.SetErrorStringWithFormat("Couldn't dematerialize a result variable: " "couldn't get the corresponding type " "system: %s", - type_system_error.AsCString()); + llvm::toString(std::move(error)).c_str()); return; } - PersistentExpressionState *persistent_state = - type_system->GetPersistentExpressionState(); + type_system_or_err->GetPersistentExpressionState(); if (!persistent_state) { err.SetErrorString("Couldn't dematerialize a result variable: " diff --git a/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp b/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp index 5910d062b..53e9c2cca 100644 --- a/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp +++ b/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp @@ -74,14 +74,19 @@ void ClangASTSource::InstallASTContext(clang::ASTContext &ast_context, file_manager}; std::vector<clang::ExternalASTMerger::ImporterSource> sources; for (lldb::ModuleSP module_sp : m_target->GetImages().Modules()) { - if (auto *module_ast_ctx = llvm::cast_or_null<ClangASTContext>( - module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC))) { + auto type_system_or_err = + module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS), + std::move(err), "Failed to get ClangASTContext"); + } else if (auto *module_ast_ctx = llvm::cast_or_null<ClangASTContext>( + &type_system_or_err.get())) { lldbassert(module_ast_ctx->getASTContext()); lldbassert(module_ast_ctx->getFileManager()); sources.push_back({*module_ast_ctx->getASTContext(), *module_ast_ctx->getFileManager(), - module_ast_ctx->GetOriginMap() - }); + module_ast_ctx->GetOriginMap()}); } } diff --git a/source/Plugins/Language/CPlusPlus/BlockPointer.cpp b/source/Plugins/Language/CPlusPlus/BlockPointer.cpp index 87b5b5947..5cfd97877 100644 --- a/source/Plugins/Language/CPlusPlus/BlockPointer.cpp +++ b/source/Plugins/Language/CPlusPlus/BlockPointer.cpp @@ -17,6 +17,7 @@ #include "lldb/Target/Target.h" #include "lldb/Utility/LLDBAssert.h" +#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; @@ -39,16 +40,17 @@ public: return; } - Status err; - TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage( - &err, lldb::eLanguageTypeC_plus_plus); - - if (!err.Success() || !type_system) { + auto type_system_or_err = target_sp->GetScratchTypeSystemForLanguage( + lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS), + std::move(err), "Failed to get scratch ClangASTContext"); return; } ClangASTContext *clang_ast_context = - llvm::dyn_cast<ClangASTContext>(type_system); + llvm::dyn_cast<ClangASTContext>(&type_system_or_err.get()); if (!clang_ast_context) { return; diff --git a/source/Plugins/Language/ObjC/CoreMedia.cpp b/source/Plugins/Language/ObjC/CoreMedia.cpp index d19290ec5..247429da1 100644 --- a/source/Plugins/Language/ObjC/CoreMedia.cpp +++ b/source/Plugins/Language/ObjC/CoreMedia.cpp @@ -10,6 +10,7 @@ #include "CoreMedia.h" #include "lldb/Utility/Flags.h" +#include "lldb/Utility/Log.h" #include "lldb/Symbol/TypeSystem.h" #include "lldb/Target/Target.h" @@ -25,18 +26,21 @@ bool lldb_private::formatters::CMTimeSummaryProvider( if (!type.IsValid()) return false; - TypeSystem *type_system = + auto type_system_or_err = valobj.GetExecutionContextRef() .GetTargetSP() - ->GetScratchTypeSystemForLanguage(nullptr, lldb::eLanguageTypeC); - if (!type_system) + ->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS), + std::move(err), "Failed to get scratch type system"); return false; - + } // fetch children by offset to compensate for potential lack of debug info - auto int64_ty = - type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 64); - auto int32_ty = - type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 32); + auto int64_ty = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize( + eEncodingSint, 64); + auto int32_ty = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize( + eEncodingSint, 32); auto value_sp(valobj.GetSyntheticChildAtOffset(0, int64_ty, true)); auto timescale_sp(valobj.GetSyntheticChildAtOffset(8, int32_ty, true)); diff --git a/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h b/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h index 680363606..7eb865765 100644 --- a/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h +++ b/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h @@ -118,8 +118,11 @@ public: size_t FindTypes(const std::vector<CompilerContext> &context, bool append, TypeMap &types) override; - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override { - return nullptr; + llvm::Expected<TypeSystem &> + GetTypeSystemForLanguage(lldb::LanguageType language) override { + return llvm::make_error<llvm::StringError>( + "SymbolFileBreakpad does not support GetTypeSystemForLanguage", + llvm::inconvertibleErrorCode()); } CompilerDeclContext diff --git a/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp b/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp index 96adb72c9..8b2ae12b4 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp +++ b/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp @@ -14,6 +14,7 @@ #include "lldb/Core/Module.h" #include "lldb/Symbol/ObjectFile.h" +#include "lldb/Utility/Log.h" using namespace lldb_private; @@ -102,19 +103,22 @@ SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const { return nullptr; } -lldb_private::TypeSystem *DWARFBaseDIE::GetTypeSystem() const { - if (m_cu) - return m_cu->GetTypeSystem(); - else - return nullptr; +llvm::Expected<lldb_private::TypeSystem &> DWARFBaseDIE::GetTypeSystem() const { + if (!m_cu) + return llvm::make_error<llvm::StringError>( + "Unable to get TypeSystem, no compilation unit available", + llvm::inconvertibleErrorCode()); + return m_cu->GetTypeSystem(); } DWARFASTParser *DWARFBaseDIE::GetDWARFParser() const { - lldb_private::TypeSystem *type_system = GetTypeSystem(); - if (type_system) - return type_system->GetDWARFParser(); - else + auto type_system_or_err = GetTypeSystem(); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to get DWARFASTParser"); return nullptr; + } + return type_system_or_err->GetDWARFParser(); } bool DWARFBaseDIE::HasChildren() const { diff --git a/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h b/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h index 005804301..9652d7946 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h +++ b/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h @@ -12,6 +12,8 @@ #include "lldb/Core/dwarf.h" #include "lldb/lldb-types.h" +#include "llvm/Support/Error.h" + class DIERef; class DWARFASTParser; class DWARFAttributes; @@ -55,7 +57,7 @@ public: llvm::Optional<DIERef> GetDIERef() const; - lldb_private::TypeSystem *GetTypeSystem() const; + llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem() const; DWARFASTParser *GetDWARFParser() const; diff --git a/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp b/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp index 0c60ae822..acc744552 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp +++ b/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp @@ -438,7 +438,7 @@ lldb::ByteOrder DWARFUnit::GetByteOrder() const { return m_dwarf.GetObjectFile()->GetByteOrder(); } -TypeSystem *DWARFUnit::GetTypeSystem() { +llvm::Expected<TypeSystem &> DWARFUnit::GetTypeSystem() { return m_dwarf.GetTypeSystemForLanguage(GetLanguageType()); } diff --git a/source/Plugins/SymbolFile/DWARF/DWARFUnit.h b/source/Plugins/SymbolFile/DWARF/DWARFUnit.h index 8aa1e449f..87e0de283 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFUnit.h +++ b/source/Plugins/SymbolFile/DWARF/DWARFUnit.h @@ -153,7 +153,7 @@ public: lldb::ByteOrder GetByteOrder() const; - lldb_private::TypeSystem *GetTypeSystem(); + llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem(); const DWARFDebugAranges &GetFunctionAranges(); diff --git a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp index bb45c921e..8e9ff5dea 100644 --- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp +++ b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp @@ -364,17 +364,17 @@ UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() { return m_unique_ast_type_map; } -TypeSystem *SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) { - SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); - TypeSystem *type_system; - if (debug_map_symfile) { - type_system = debug_map_symfile->GetTypeSystemForLanguage(language); - } else { - type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language); - if (type_system) - type_system->SetSymbolFile(this); +llvm::Expected<TypeSystem &> +SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) { + if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile()) + return debug_map_symfile->GetTypeSystemForLanguage(language); + + auto type_system_or_err = + m_obj_file->GetModule()->GetTypeSystemForLanguage(language); + if (type_system_or_err) { + type_system_or_err->SetSymbolFile(this); } - return type_system; + return type_system_or_err; } void SymbolFileDWARF::InitializeObject() { @@ -730,17 +730,21 @@ CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) { Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit, const DWARFDIE &die) { ASSERT_MODULE_LOCK(this); - if (die.IsValid()) { - TypeSystem *type_system = - GetTypeSystemForLanguage(die.GetCU()->GetLanguageType()); - - if (type_system) { - DWARFASTParser *dwarf_ast = type_system->GetDWARFParser(); - if (dwarf_ast) - return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die); - } + if (!die.IsValid()) + return nullptr; + + auto type_system_or_err = + GetTypeSystemForLanguage(die.GetCU()->GetLanguageType()); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to parse function"); + return nullptr; } - return nullptr; + DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser(); + if (!dwarf_ast) + return nullptr; + + return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die); } bool SymbolFileDWARF::FixupAddress(Address &addr) { @@ -1177,7 +1181,9 @@ bool SymbolFileDWARF::ClassOrStructIsVirtual(const DWARFDIE &parent_die) { } void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) { - TypeSystem *type_system = decl_ctx.GetTypeSystem(); + auto *type_system = decl_ctx.GetTypeSystem(); + if (!type_system) + return; DWARFASTParser *ast_parser = type_system->GetDWARFParser(); std::vector<DWARFDIE> decl_ctx_die_list = ast_parser->GetDIEForDeclContext(decl_ctx); @@ -1948,9 +1954,16 @@ bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile( } TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem(); - TypeSystem *type_system = GetTypeSystemForLanguage( + auto type_system_or_err = GetTypeSystemForLanguage( decl_ctx_type_system->GetMinimumLanguage(nullptr)); - if (decl_ctx_type_system == type_system) + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), + "Unable to match namespace decl using TypeSystem"); + return false; + } + + if (decl_ctx_type_system == &type_system_or_err.get()) return true; // The type systems match, return true // The namespace AST was valid, and it does not match... @@ -2857,10 +2870,18 @@ TypeSP SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext( // use this to ensure any matches we find are in a language that this // type system supports const LanguageType language = dwarf_decl_ctx.GetLanguage(); - TypeSystem *type_system = (language == eLanguageTypeUnknown) - ? nullptr - : GetTypeSystemForLanguage(language); - + TypeSystem *type_system = nullptr; + if (language != eLanguageTypeUnknown) { + auto type_system_or_err = GetTypeSystemForLanguage(language); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Cannot get TypeSystem for language {}", + Language::GetNameForLanguageType(language)); + } else { + type_system = &type_system_or_err.get(); + } + } if (num_matches) { for (size_t i = 0; i < num_matches; ++i) { const DIERef &die_ref = die_offsets[i]; @@ -2954,12 +2975,15 @@ TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die, if (!die) return {}; - TypeSystem *type_system = + auto type_system_or_err = GetTypeSystemForLanguage(die.GetCU()->GetLanguageType()); - if (!type_system) + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to parse type"); return {}; + } - DWARFASTParser *dwarf_ast = type_system->GetDWARFParser(); + DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser(); if (!dwarf_ast) return {}; @@ -3711,8 +3735,10 @@ void SymbolFileDWARF::Dump(lldb_private::Stream &s) { } void SymbolFileDWARF::DumpClangAST(Stream &s) { - TypeSystem *ts = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus); - ClangASTContext *clang = llvm::dyn_cast_or_null<ClangASTContext>(ts); + auto ts_or_err = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus); + if (!ts_or_err) + return; + ClangASTContext *clang = llvm::dyn_cast_or_null<ClangASTContext>(&ts_or_err.get()); if (!clang) return; clang->Dump(s); diff --git a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h index 97c75ade6..4f5a9096b 100644 --- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h +++ b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h @@ -191,7 +191,7 @@ public: lldb::TypeClass type_mask, lldb_private::TypeList &type_list) override; - lldb_private::TypeSystem * + llvm::Expected<lldb_private::TypeSystem &> GetTypeSystemForLanguage(lldb::LanguageType language) override; lldb_private::CompilerDeclContext FindNamespace( diff --git a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp index c5b54b65e..ed98658c3 100644 --- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp +++ b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp @@ -140,7 +140,7 @@ SymbolFileDWARFDwo::GetLocationListFormat() const { return DWARFExpression::SplitDwarfLocationList; } -TypeSystem * +llvm::Expected<TypeSystem &> SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) { return GetBaseSymbolFile().GetTypeSystemForLanguage(language); } diff --git a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h index 9b2f3bb84..01c8bec12 100644 --- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h +++ b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h @@ -30,7 +30,7 @@ public: size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name, DIEArray &method_die_offsets) override; - lldb_private::TypeSystem * + llvm::Expected<lldb_private::TypeSystem &> GetTypeSystemForLanguage(lldb::LanguageType language) override; DWARFDIE diff --git a/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp b/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp index a78f60979..6ab45de44 100644 --- a/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp +++ b/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp @@ -121,13 +121,6 @@ AnyScopesHaveTemplateParams(llvm::ArrayRef<llvm::ms_demangle::Node *> scopes) { return false; } -static ClangASTContext &GetClangASTContext(ObjectFile &obj) { - TypeSystem *ts = - obj.GetModule()->GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); - lldbassert(ts); - return static_cast<ClangASTContext &>(*ts); -} - static llvm::Optional<clang::CallingConv> TranslateCallingConvention(llvm::codeview::CallingConvention conv) { using CC = llvm::codeview::CallingConvention; @@ -209,8 +202,8 @@ static bool IsAnonymousNamespaceName(llvm::StringRef name) { return name == "`anonymous namespace'" || name == "`anonymous-namespace'"; } -PdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index) - : m_index(index), m_clang(GetClangASTContext(obj)) { +PdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index, ClangASTContext &clang) + : m_index(index), m_clang(clang) { BuildParentMap(); } diff --git a/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h b/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h index 593bf05eb..a4242e908 100644 --- a/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h +++ b/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h @@ -51,7 +51,7 @@ struct DeclStatus { class PdbAstBuilder { public: // Constructors and Destructors - PdbAstBuilder(ObjectFile &obj, PdbIndex &index); + PdbAstBuilder(ObjectFile &obj, PdbIndex &index, ClangASTContext &clang); lldb_private::CompilerDeclContext GetTranslationUnitDecl(); diff --git a/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp b/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp index 572ec7d6f..59ea31ee2 100644 --- a/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp +++ b/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp @@ -30,6 +30,7 @@ #include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/Variable.h" #include "lldb/Symbol/VariableList.h" +#include "lldb/Utility/Log.h" #include "llvm/DebugInfo/CodeView/CVRecord.h" #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h" @@ -321,12 +322,17 @@ void SymbolFileNativePDB::InitializeObject() { m_index->SetLoadAddress(m_obj_load_address); m_index->ParseSectionContribs(); - TypeSystem *ts = m_obj_file->GetModule()->GetTypeSystemForLanguage( + auto ts_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage( lldb::eLanguageTypeC_plus_plus); - if (ts) - ts->SetSymbolFile(this); - - m_ast = llvm::make_unique<PdbAstBuilder>(*m_obj_file, *m_index); + if (auto err = ts_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Failed to initialize"); + } else { + ts_or_err->SetSymbolFile(this); + auto *clang = llvm::cast_or_null<ClangASTContext>(&ts_or_err.get()); + lldbassert(clang); + m_ast = llvm::make_unique<PdbAstBuilder>(*m_obj_file, *m_index, *clang); + } } uint32_t SymbolFileNativePDB::CalculateNumCompileUnits() { @@ -1585,13 +1591,14 @@ SymbolFileNativePDB::FindNamespace(ConstString name, return {}; } -TypeSystem * +llvm::Expected<TypeSystem &> SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) { - auto type_system = + auto type_system_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage(language); - if (type_system) - type_system->SetSymbolFile(this); - return type_system; + if (type_system_or_err) { + type_system_or_err->SetSymbolFile(this); + } + return type_system_or_err; } ConstString SymbolFileNativePDB::GetPluginName() { diff --git a/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h b/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h index 88bd5de54..49b68ae80 100644 --- a/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h +++ b/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h @@ -137,7 +137,8 @@ public: size_t FindTypes(const std::vector<CompilerContext> &context, bool append, TypeMap &types) override; - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override; + llvm::Expected<TypeSystem &> + GetTypeSystemForLanguage(lldb::LanguageType language) override; CompilerDeclContext FindNamespace(ConstString name, diff --git a/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp b/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp index 2a3240692..664c142d7 100644 --- a/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp +++ b/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp @@ -24,6 +24,7 @@ #include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeMap.h" #include "lldb/Symbol/Variable.h" +#include "lldb/Utility/Log.h" #include "lldb/Utility/RegularExpression.h" #include "llvm/DebugInfo/PDB/GenericError.h" @@ -299,11 +300,15 @@ SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func, comp_unit.AddFunction(func_sp); LanguageType lang = ParseLanguage(comp_unit); - TypeSystem *type_system = GetTypeSystemForLanguage(lang); - if (!type_system) + auto type_system_or_err = GetTypeSystemForLanguage(lang); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to parse PDBFunc"); return nullptr; + } + ClangASTContext *clang_type_system = - llvm::dyn_cast_or_null<ClangASTContext>(type_system); + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); if (!clang_type_system) return nullptr; clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func); @@ -548,10 +553,16 @@ lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) { if (find_result != m_types.end()) return find_result->second.get(); - TypeSystem *type_system = + auto type_system_or_err = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to ResolveTypeUID"); + return nullptr; + } + ClangASTContext *clang_type_system = - llvm::dyn_cast_or_null<ClangASTContext>(type_system); + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); if (!clang_type_system) return nullptr; PDBASTParser *pdb = clang_type_system->GetPDBParser(); @@ -579,8 +590,17 @@ bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) { std::lock_guard<std::recursive_mutex> guard( GetObjectFile()->GetModule()->GetMutex()); - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to get dynamic array info for UID"); + return false; + } + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); + if (!clang_ast_ctx) return false; @@ -592,8 +612,16 @@ bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) { } lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) { - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to get decl for UID"); + return CompilerDecl(); + } + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); if (!clang_ast_ctx) return CompilerDecl(); @@ -614,8 +642,16 @@ lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) { lldb_private::CompilerDeclContext SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) { - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to get DeclContext for UID"); + return CompilerDeclContext(); + } + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); if (!clang_ast_ctx) return CompilerDeclContext(); @@ -636,8 +672,16 @@ SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) { lldb_private::CompilerDeclContext SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) { - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to get DeclContext containing UID"); + return CompilerDeclContext(); + } + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); if (!clang_ast_ctx) return CompilerDeclContext(); @@ -657,8 +701,16 @@ SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) { void SymbolFilePDB::ParseDeclsForContext( lldb_private::CompilerDeclContext decl_ctx) { - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to parse decls for context"); + return; + } + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); if (!clang_ast_ctx) return; @@ -1412,11 +1464,19 @@ uint32_t SymbolFilePDB::FindTypes( } void SymbolFilePDB::DumpClangAST(Stream &s) { - auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); - auto clang = llvm::dyn_cast_or_null<ClangASTContext>(type_system); - if (!clang) + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to dump ClangAST"); return; - clang->Dump(s); + } + + auto *clang_type_system = + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); + if (!clang_type_system) + return; + clang_type_system->Dump(s); } void SymbolFilePDB::FindTypesByRegex( @@ -1609,18 +1669,27 @@ size_t SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope, return type_list.GetSize() - old_size; } -lldb_private::TypeSystem * +llvm::Expected<lldb_private::TypeSystem &> SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) { - auto type_system = + auto type_system_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage(language); - if (type_system) - type_system->SetSymbolFile(this); - return type_system; + if (type_system_or_err) { + type_system_or_err->SetSymbolFile(this); + } + return type_system_or_err; } PDBASTParser *SymbolFilePDB::GetPDBAstParser() { - auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); - auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to get PDB AST parser"); + return nullptr; + } + + auto *clang_type_system = + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); if (!clang_type_system) return nullptr; @@ -1632,8 +1701,17 @@ lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace( lldb_private::ConstString name, const lldb_private::CompilerDeclContext *parent_decl_ctx) { std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); - auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); - auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), "Unable to find namespace {}", + name.AsCString()); + return CompilerDeclContext(); + } + + auto *clang_type_system = + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); if (!clang_type_system) return CompilerDeclContext(); @@ -1651,7 +1729,7 @@ lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace( if (!namespace_decl) return CompilerDeclContext(); - return CompilerDeclContext(type_system, + return CompilerDeclContext(clang_type_system, static_cast<clang::DeclContext *>(namespace_decl)); } @@ -1931,9 +2009,17 @@ bool SymbolFilePDB::DeclContextMatchesThisSymbolFile( TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem(); if (!decl_ctx_type_system) return false; - TypeSystem *type_system = GetTypeSystemForLanguage( + auto type_system_or_err = GetTypeSystemForLanguage( decl_ctx_type_system->GetMinimumLanguage(nullptr)); - if (decl_ctx_type_system == type_system) + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), + "Unable to determine if DeclContext matches this symbol file"); + return false; + } + + if (decl_ctx_type_system == &type_system_or_err.get()) return true; // The type systems match, return true return false; diff --git a/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h b/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h index fc3320256..e0f8db706 100644 --- a/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h +++ b/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h @@ -142,7 +142,7 @@ public: lldb::TypeClass type_mask, lldb_private::TypeList &type_list) override; - lldb_private::TypeSystem * + llvm::Expected<lldb_private::TypeSystem &> GetTypeSystemForLanguage(lldb::LanguageType language) override; lldb_private::CompilerDeclContext FindNamespace( diff --git a/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp b/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp index 63600b319..3f810ca43 100644 --- a/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp +++ b/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp @@ -169,14 +169,19 @@ lldb::addr_t AppleGetItemInfoHandler::SetupGetItemInfoFunction( } // Next make the runner function for our implementation utility function. - Status error; - - TypeSystem *type_system = + auto type_system_or_err = thread.GetProcess()->GetTarget().GetScratchTypeSystemForLanguage( - nullptr, eLanguageTypeC); + eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(log, std::move(err), + "Error inseting get-item-info function"); + return args_addr; + } CompilerType get_item_info_return_type = - type_system->GetBasicTypeFromAST(eBasicTypeVoid).GetPointerType(); + type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid) + .GetPointerType(); + Status error; get_item_info_caller = m_get_item_info_impl_code->MakeFunctionCaller( get_item_info_return_type, get_item_info_arglist, thread.shared_from_this(), error); diff --git a/source/Symbol/SymbolFile.cpp b/source/Symbol/SymbolFile.cpp index c7557f9d6..b88a268d7 100644 --- a/source/Symbol/SymbolFile.cpp +++ b/source/Symbol/SymbolFile.cpp @@ -85,12 +85,14 @@ SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) { return best_symfile_up.release(); } -TypeSystem *SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) { - TypeSystem *type_system = +llvm::Expected<TypeSystem &> +SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) { + auto type_system_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage(language); - if (type_system) - type_system->SetSymbolFile(this); - return type_system; + if (type_system_or_err) { + type_system_or_err->SetSymbolFile(this); + } + return type_system_or_err; } uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec, diff --git a/source/Symbol/Type.cpp b/source/Symbol/Type.cpp index c16e6471a..55be0c77c 100644 --- a/source/Symbol/Type.cpp +++ b/source/Symbol/Type.cpp @@ -11,6 +11,7 @@ #include "lldb/Core/Module.h" #include "lldb/Utility/DataBufferHeap.h" #include "lldb/Utility/DataExtractor.h" +#include "lldb/Utility/Log.h" #include "lldb/Utility/Scalar.h" #include "lldb/Utility/StreamString.h" @@ -486,47 +487,54 @@ bool Type::ResolveClangType(ResolveState compiler_type_resolve_state) { } } else { // We have no encoding type, return void? - TypeSystem *type_system = + auto type_system_or_err = m_symbol_file->GetTypeSystemForLanguage(eLanguageTypeC); - CompilerType void_compiler_type = - type_system->GetBasicTypeFromAST(eBasicTypeVoid); - switch (m_encoding_uid_type) { - case eEncodingIsUID: - m_compiler_type = void_compiler_type; - break; + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS), + std::move(err), + "Unable to construct void type from ClangASTContext"); + } else { + CompilerType void_compiler_type = + type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid); + switch (m_encoding_uid_type) { + case eEncodingIsUID: + m_compiler_type = void_compiler_type; + break; - case eEncodingIsConstUID: - m_compiler_type = void_compiler_type.AddConstModifier(); - break; + case eEncodingIsConstUID: + m_compiler_type = void_compiler_type.AddConstModifier(); + break; - case eEncodingIsRestrictUID: - m_compiler_type = void_compiler_type.AddRestrictModifier(); - break; + case eEncodingIsRestrictUID: + m_compiler_type = void_compiler_type.AddRestrictModifier(); + break; - case eEncodingIsVolatileUID: - m_compiler_type = void_compiler_type.AddVolatileModifier(); - break; + case eEncodingIsVolatileUID: + m_compiler_type = void_compiler_type.AddVolatileModifier(); + break; - case eEncodingIsTypedefUID: - m_compiler_type = void_compiler_type.CreateTypedef( - m_name.AsCString("__lldb_invalid_typedef_name"), - GetSymbolFile()->GetDeclContextContainingUID(GetID())); - break; + case eEncodingIsTypedefUID: + m_compiler_type = void_compiler_type.CreateTypedef( + m_name.AsCString("__lldb_invalid_typedef_name"), + GetSymbolFile()->GetDeclContextContainingUID(GetID())); + break; - case eEncodingIsPointerUID: - m_compiler_type = void_compiler_type.GetPointerType(); - break; + case eEncodingIsPointerUID: + m_compiler_type = void_compiler_type.GetPointerType(); + break; - case eEncodingIsLValueReferenceUID: - m_compiler_type = void_compiler_type.GetLValueReferenceType(); - break; + case eEncodingIsLValueReferenceUID: + m_compiler_type = void_compiler_type.GetLValueReferenceType(); + break; - case eEncodingIsRValueReferenceUID: - m_compiler_type = void_compiler_type.GetRValueReferenceType(); - break; + case eEncodingIsRValueReferenceUID: + m_compiler_type = void_compiler_type.GetRValueReferenceType(); + break; - default: - llvm_unreachable("Unhandled encoding_data_type."); + default: + llvm_unreachable("Unhandled encoding_data_type."); + } } } diff --git a/source/Symbol/TypeSystem.cpp b/source/Symbol/TypeSystem.cpp index fb9c8e71a..e5fd7e529 100644 --- a/source/Symbol/TypeSystem.cpp +++ b/source/Symbol/TypeSystem.cpp @@ -20,6 +20,7 @@ #include "lldb/Core/PluginManager.h" #include "lldb/Symbol/CompilerType.h" +#include "lldb/Target/Language.h" using namespace lldb_private; using namespace lldb; @@ -198,65 +199,140 @@ void TypeSystemMap::ForEach(std::function<bool(TypeSystem *)> const &callback) { } } -TypeSystem *TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language, - Module *module, - bool can_create) { +llvm::Expected<TypeSystem &> +TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language, + Module *module, bool can_create) { + llvm::Error error = llvm::Error::success(); + assert(!error); // Check the success value when assertions are enabled std::lock_guard<std::mutex> guard(m_mutex); - collection::iterator pos = m_map.find(language); - if (pos != m_map.end()) - return pos->second.get(); - - for (const auto &pair : m_map) { - if (pair.second && pair.second->SupportsLanguage(language)) { - // Add a new mapping for "language" to point to an already existing - // TypeSystem that supports this language - AddToMap(language, pair.second); - return pair.second.get(); + if (m_clear_in_progress) { + error = llvm::make_error<llvm::StringError>( + "Unable to get TypeSystem because TypeSystemMap is being cleared", + llvm::inconvertibleErrorCode()); + } else { + collection::iterator pos = m_map.find(language); + if (pos != m_map.end()) { + auto *type_system = pos->second.get(); + if (type_system) { + llvm::consumeError(std::move(error)); + return *type_system; + } + error = llvm::make_error<llvm::StringError>( + "TypeSystem for language " + + llvm::toStringRef(Language::GetNameForLanguageType(language)) + + " doesn't exist", + llvm::inconvertibleErrorCode()); + return std::move(error); + } + + for (const auto &pair : m_map) { + if (pair.second && pair.second->SupportsLanguage(language)) { + // Add a new mapping for "language" to point to an already existing + // TypeSystem that supports this language + m_map[language] = pair.second; + if (pair.second.get()) { + llvm::consumeError(std::move(error)); + return *pair.second.get(); + } + error = llvm::make_error<llvm::StringError>( + "TypeSystem for language " + + llvm::toStringRef(Language::GetNameForLanguageType(language)) + + " doesn't exist", + llvm::inconvertibleErrorCode()); + return std::move(error); + } } - } - if (!can_create) - return nullptr; + if (!can_create) { + error = llvm::make_error<llvm::StringError>( + "Unable to find type system for language " + + llvm::toStringRef(Language::GetNameForLanguageType(language)), + llvm::inconvertibleErrorCode()); + } else { + // Cache even if we get a shared pointer that contains a null type system + // back + auto type_system_sp = TypeSystem::CreateInstance(language, module); + m_map[language] = type_system_sp; + if (type_system_sp.get()) { + llvm::consumeError(std::move(error)); + return *type_system_sp.get(); + } + error = llvm::make_error<llvm::StringError>( + "TypeSystem for language " + + llvm::toStringRef(Language::GetNameForLanguageType(language)) + + " doesn't exist", + llvm::inconvertibleErrorCode()); + } + } - // Cache even if we get a shared pointer that contains null type system back - lldb::TypeSystemSP type_system_sp = - TypeSystem::CreateInstance(language, module); - AddToMap(language, type_system_sp); - return type_system_sp.get(); + return std::move(error); } -TypeSystem *TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language, - Target *target, - bool can_create) { +llvm::Expected<TypeSystem &> +TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language, + Target *target, bool can_create) { + llvm::Error error = llvm::Error::success(); + assert(!error); // Check the success value when assertions are enabled std::lock_guard<std::mutex> guard(m_mutex); - collection::iterator pos = m_map.find(language); - if (pos != m_map.end()) - return pos->second.get(); + if (m_clear_in_progress) { + error = llvm::make_error<llvm::StringError>( + "Unable to get TypeSystem because TypeSystemMap is being cleared", + llvm::inconvertibleErrorCode()); + } else { + collection::iterator pos = m_map.find(language); + if (pos != m_map.end()) { + auto *type_system = pos->second.get(); + if (type_system) { + llvm::consumeError(std::move(error)); + return *type_system; + } + error = llvm::make_error<llvm::StringError>( + "TypeSystem for language " + + llvm::toStringRef(Language::GetNameForLanguageType(language)) + + " doesn't exist", + llvm::inconvertibleErrorCode()); + return std::move(error); + } - for (const auto &pair : m_map) { - if (pair.second && pair.second->SupportsLanguage(language)) { - // Add a new mapping for "language" to point to an already existing - // TypeSystem that supports this language + for (const auto &pair : m_map) { + if (pair.second && pair.second->SupportsLanguage(language)) { + // Add a new mapping for "language" to point to an already existing + // TypeSystem that supports this language + m_map[language] = pair.second; + if (pair.second.get()) { + llvm::consumeError(std::move(error)); + return *pair.second.get(); + } + error = llvm::make_error<llvm::StringError>( + "TypeSystem for language " + + llvm::toStringRef(Language::GetNameForLanguageType(language)) + + " doesn't exist", + llvm::inconvertibleErrorCode()); + return std::move(error); + } + } - AddToMap(language, pair.second); - return pair.second.get(); + if (!can_create) { + error = llvm::make_error<llvm::StringError>( + "Unable to find type system for language " + + llvm::toStringRef(Language::GetNameForLanguageType(language)), + llvm::inconvertibleErrorCode()); + } else { + // Cache even if we get a shared pointer that contains a null type system + // back + auto type_system_sp = TypeSystem::CreateInstance(language, target); + m_map[language] = type_system_sp; + if (type_system_sp.get()) { + llvm::consumeError(std::move(error)); + return *type_system_sp.get(); + } + error = llvm::make_error<llvm::StringError>( + "TypeSystem for language " + + llvm::toStringRef(Language::GetNameForLanguageType(language)) + + " doesn't exist", + llvm::inconvertibleErrorCode()); } } - if (!can_create) - return nullptr; - - // Cache even if we get a shared pointer that contains null type system back - lldb::TypeSystemSP type_system_sp; - if (!m_clear_in_progress) - type_system_sp = TypeSystem::CreateInstance(language, target); - - AddToMap(language, type_system_sp); - return type_system_sp.get(); -} - -void TypeSystemMap::AddToMap(lldb::LanguageType language, - lldb::TypeSystemSP const &type_system_sp) { - if (!m_clear_in_progress) - m_map[language] = type_system_sp; + return std::move(error); } diff --git a/source/Target/StackFrame.cpp b/source/Target/StackFrame.cpp index f8b22d96e..1bc8165d7 100644 --- a/source/Target/StackFrame.cpp +++ b/source/Target/StackFrame.cpp @@ -29,6 +29,7 @@ #include "lldb/Target/StackFrameRecognizer.h" #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" +#include "lldb/Utility/Log.h" #include "lldb/Utility/RegisterValue.h" #include "lldb/lldb-enumerations.h" @@ -1357,13 +1358,16 @@ lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) { if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate + base_and_offset.second, addr)) { - TypeSystem *c_type_system = - target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC); - if (!c_type_system) { + auto c_type_system_or_err = + target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC); + if (auto err = c_type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD), + std::move(err), "Unable to guess value for given address"); return ValueObjectSP(); } else { CompilerType void_ptr_type = - c_type_system + c_type_system_or_err ->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar) .GetPointerType(); return ValueObjectMemory::Create(this, "", addr, void_ptr_type); diff --git a/source/Target/Target.cpp b/source/Target/Target.cpp index 7b0960aaf..568eec389 100644 --- a/source/Target/Target.cpp +++ b/source/Target/Target.cpp @@ -2119,15 +2119,12 @@ void Target::ImageSearchPathsChanged(const PathMappingList &path_list, target->SetExecutableModule(exe_module_sp, eLoadDependentsYes); } -TypeSystem *Target::GetScratchTypeSystemForLanguage(Status *error, - lldb::LanguageType language, - bool create_on_demand) { +llvm::Expected<TypeSystem &> +Target::GetScratchTypeSystemForLanguage(lldb::LanguageType language, + bool create_on_demand) { if (!m_valid) - return nullptr; - - if (error) { - error->Clear(); - } + return llvm::make_error<llvm::StringError>("Invalid Target", + llvm::inconvertibleErrorCode()); if (language == eLanguageTypeMipsAssembler // GNU AS and LLVM use it for all // assembly code @@ -2143,7 +2140,9 @@ TypeSystem *Target::GetScratchTypeSystemForLanguage(Status *error, // target language. } else { if (languages_for_expressions.empty()) { - return nullptr; + return llvm::make_error<llvm::StringError>( + "No expression support for any languages", + llvm::inconvertibleErrorCode()); } else { language = *languages_for_expressions.begin(); } @@ -2156,14 +2155,17 @@ TypeSystem *Target::GetScratchTypeSystemForLanguage(Status *error, PersistentExpressionState * Target::GetPersistentExpressionStateForLanguage(lldb::LanguageType language) { - TypeSystem *type_system = - GetScratchTypeSystemForLanguage(nullptr, language, true); + auto type_system_or_err = GetScratchTypeSystemForLanguage(language, true); - if (type_system) { - return type_system->GetPersistentExpressionState(); - } else { + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET), + std::move(err), + "Unable to get persistent expression state for language {}", + Language::GetNameForLanguageType(language)); return nullptr; } + + return type_system_or_err->GetPersistentExpressionState(); } UserExpression *Target::GetUserExpressionForLanguage( @@ -2171,22 +2173,17 @@ UserExpression *Target::GetUserExpressionForLanguage( Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj, Status &error) { - Status type_system_error; - - TypeSystem *type_system = - GetScratchTypeSystemForLanguage(&type_system_error, language); - UserExpression *user_expr = nullptr; - - if (!type_system) { + auto type_system_or_err = GetScratchTypeSystemForLanguage(language); + if (auto err = type_system_or_err.takeError()) { error.SetErrorStringWithFormat( "Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), - type_system_error.AsCString()); + llvm::toString(std::move(err)).c_str()); return nullptr; } - user_expr = type_system->GetUserExpression(expr, prefix, language, - desired_type, options, ctx_obj); + auto *user_expr = type_system_or_err->GetUserExpression( + expr, prefix, language, desired_type, options, ctx_obj); if (!user_expr) error.SetErrorStringWithFormat( "Could not create an expression for language %s", @@ -2199,21 +2196,17 @@ FunctionCaller *Target::GetFunctionCallerForLanguage( lldb::LanguageType language, const CompilerType &return_type, const Address &function_address, const ValueList &arg_value_list, const char *name, Status &error) { - Status type_system_error; - TypeSystem *type_system = - GetScratchTypeSystemForLanguage(&type_system_error, language); - FunctionCaller *persistent_fn = nullptr; - - if (!type_system) { + auto type_system_or_err = GetScratchTypeSystemForLanguage(language); + if (auto err = type_system_or_err.takeError()) { error.SetErrorStringWithFormat( "Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), - type_system_error.AsCString()); - return persistent_fn; + llvm::toString(std::move(err)).c_str()); + return nullptr; } - persistent_fn = type_system->GetFunctionCaller(return_type, function_address, - arg_value_list, name); + auto *persistent_fn = type_system_or_err->GetFunctionCaller( + return_type, function_address, arg_value_list, name); if (!persistent_fn) error.SetErrorStringWithFormat( "Could not create an expression for language %s", @@ -2226,20 +2219,17 @@ UtilityFunction * Target::GetUtilityFunctionForLanguage(const char *text, lldb::LanguageType language, const char *name, Status &error) { - Status type_system_error; - TypeSystem *type_system = - GetScratchTypeSystemForLanguage(&type_system_error, language); - UtilityFunction *utility_fn = nullptr; + auto type_system_or_err = GetScratchTypeSystemForLanguage(language); - if (!type_system) { + if (auto err = type_system_or_err.takeError()) { error.SetErrorStringWithFormat( "Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), - type_system_error.AsCString()); - return utility_fn; + llvm::toString(std::move(err)).c_str()); + return nullptr; } - utility_fn = type_system->GetUtilityFunction(text, name); + auto *utility_fn = type_system_or_err->GetUtilityFunction(text, name); if (!utility_fn) error.SetErrorStringWithFormat( "Could not create an expression for language %s", @@ -2249,12 +2239,17 @@ Target::GetUtilityFunctionForLanguage(const char *text, } ClangASTContext *Target::GetScratchClangASTContext(bool create_on_demand) { - if (m_valid) { - if (TypeSystem *type_system = GetScratchTypeSystemForLanguage( - nullptr, eLanguageTypeC, create_on_demand)) - return llvm::dyn_cast<ClangASTContext>(type_system); + if (!m_valid) + return nullptr; + + auto type_system_or_err = + GetScratchTypeSystemForLanguage(eLanguageTypeC, create_on_demand); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET), + std::move(err), "Couldn't get scratch ClangASTContext"); + return nullptr; } - return nullptr; + return llvm::dyn_cast<ClangASTContext>(&type_system_or_err.get()); } ClangASTImporterSP Target::GetClangASTImporter() { @@ -2348,13 +2343,19 @@ ExpressionResults Target::EvaluateExpression( // Make sure we aren't just trying to see the value of a persistent variable // (something like "$0") - lldb::ExpressionVariableSP persistent_var_sp; // Only check for persistent variables the expression starts with a '$' - if (expr[0] == '$') - persistent_var_sp = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC) - ->GetPersistentExpressionState() - ->GetVariable(expr); - + lldb::ExpressionVariableSP persistent_var_sp; + if (expr[0] == '$') { + auto type_system_or_err = + GetScratchTypeSystemForLanguage(eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET), + std::move(err), "Unable to get scratch type system"); + } else { + persistent_var_sp = + type_system_or_err->GetPersistentExpressionState()->GetVariable(expr); + } + } if (persistent_var_sp) { result_valobj_sp = persistent_var_sp->GetValueObject(); execution_results = eExpressionCompleted; diff --git a/source/Target/ThreadPlanTracer.cpp b/source/Target/ThreadPlanTracer.cpp index 4e79b6b1e..ed4e17840 100644 --- a/source/Target/ThreadPlanTracer.cpp +++ b/source/Target/ThreadPlanTracer.cpp @@ -93,15 +93,20 @@ Disassembler *ThreadPlanAssemblyTracer::GetDisassembler() { TypeFromUser ThreadPlanAssemblyTracer::GetIntPointerType() { if (!m_intptr_type.IsValid()) { - TargetSP target_sp(m_thread.CalculateTarget()); - if (target_sp) { - TypeSystem *type_system = - target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC); - if (type_system) - m_intptr_type = - TypeFromUser(type_system->GetBuiltinTypeForEncodingAndBitSize( + if (auto target_sp = m_thread.CalculateTarget()) { + auto type_system_or_err = + target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + LLDB_LOG_ERROR( + lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TYPES), + std::move(err), + "Unable to get integer pointer type from TypeSystem"); + } else { + m_intptr_type = TypeFromUser( + type_system_or_err->GetBuiltinTypeForEncodingAndBitSize( eEncodingUint, target_sp->GetArchitecture().GetAddressByteSize() * 8)); + } } } return m_intptr_type; diff --git a/tools/lldb-test/lldb-test.cpp b/tools/lldb-test/lldb-test.cpp index 05039af23..d44b6fdc2 100644 --- a/tools/lldb-test/lldb-test.cpp +++ b/tools/lldb-test/lldb-test.cpp @@ -528,10 +528,15 @@ Error opts::symbols::dumpAST(lldb_private::Module &Module) { if (!symfile) return make_string_error("Module has no symbol file."); - auto clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>( - symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus)); + auto type_system_or_err = + symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus); + if (!type_system_or_err) + return make_string_error("Can't retrieve ClangASTContext"); + + auto *clang_ast_ctx = + llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get()); if (!clang_ast_ctx) - return make_string_error("Can't retrieve Clang AST context."); + return make_string_error("Retrieved TypeSystem was not a ClangASTContext"); auto ast_ctx = clang_ast_ctx->getASTContext(); if (!ast_ctx) |