Index: include/lldb/Core/Module.h =================================================================== --- include/lldb/Core/Module.h +++ include/lldb/Core/Module.h @@ -819,7 +819,8 @@ bool GetIsDynamicLinkEditor(); - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language); + llvm::Expected + 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 Index: include/lldb/Symbol/SymbolFile.h =================================================================== --- include/lldb/Symbol/SymbolFile.h +++ include/lldb/Symbol/SymbolFile.h @@ -201,7 +201,7 @@ virtual void PreloadSymbols(); - virtual lldb_private::TypeSystem * + virtual llvm::Expected GetTypeSystemForLanguage(lldb::LanguageType language); virtual CompilerDeclContext Index: include/lldb/Symbol/TypeSystem.h =================================================================== --- include/lldb/Symbol/TypeSystem.h +++ 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 @@ // callback to keep iterating, false to stop iterating. void ForEach(std::function const &callback); - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language, - Module *module, bool can_create); + llvm::Expected + GetTypeSystemForLanguage(lldb::LanguageType language, Module *module, + bool can_create); - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language, - Target *target, bool can_create); + llvm::Expected + 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 collection; mutable std::mutex m_mutex; ///< A mutex to keep this object happy in ///multi-threaded environments. Index: include/lldb/Target/Target.h =================================================================== --- include/lldb/Target/Target.h +++ include/lldb/Target/Target.h @@ -1022,9 +1022,9 @@ PathMappingList &GetImageSearchPathList(); - TypeSystem *GetScratchTypeSystemForLanguage(Status *error, - lldb::LanguageType language, - bool create_on_demand = true); + llvm::Expected + GetScratchTypeSystemForLanguage(lldb::LanguageType language, + bool create_on_demand = true); PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language); Index: source/API/SBModule.cpp =================================================================== --- source/API/SBModule.cpp +++ source/API/SBModule.cpp @@ -468,10 +468,11 @@ sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match)); if (!sb_type.IsValid()) { - TypeSystem *type_system = - module_sp->GetTypeSystemForLanguage(eLanguageTypeC); - if (type_system) + if (auto type_system_or_err = + module_sp->GetTypeSystemForLanguage(eLanguageTypeC)) { + auto *type_system = *type_system_or_err; sb_type = SBType(type_system->GetBuiltinTypeByName(name)); + } } } return LLDB_RECORD_RESULT(sb_type); @@ -483,10 +484,11 @@ ModuleSP module_sp(GetSP()); if (module_sp) { - TypeSystem *type_system = - module_sp->GetTypeSystemForLanguage(eLanguageTypeC); - if (type_system) + if (auto type_system_or_err = + module_sp->GetTypeSystemForLanguage(eLanguageTypeC)) { + auto *type_system = *type_system_or_err; return LLDB_RECORD_RESULT(SBType(type_system->GetBasicTypeFromAST(type))); + } } return LLDB_RECORD_RESULT(SBType()); } @@ -513,9 +515,9 @@ retval.Append(SBType(type_sp)); } } else { - TypeSystem *type_system = - module_sp->GetTypeSystemForLanguage(eLanguageTypeC); - if (type_system) { + if (auto type_system_or_err = + module_sp->GetTypeSystemForLanguage(eLanguageTypeC)) { + auto *type_system = *type_system_or_err; CompilerType compiler_type = type_system->GetBuiltinTypeByName(name); if (compiler_type) retval.Append(SBType(compiler_type)); Index: source/Breakpoint/Watchpoint.cpp =================================================================== --- source/Breakpoint/Watchpoint.cpp +++ 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,25 @@ 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) { + + Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS)); 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 (!type_system_or_err) { + if (log) + log->Printf( + "Watchpoint::Watchpoint(): Failed to set type.\nReason: %s", + llvm::toString(type_system_or_err.takeError()).c_str()); + } else { + auto *type_system = *type_system_or_err; + m_type = type_system->GetBuiltinTypeForEncodingAndBitSize( + eEncodingUint, 8 * size); + } } // Set the initial value of the watched variable: Index: source/Core/Module.cpp =================================================================== --- source/Core/Module.cpp +++ source/Core/Module.cpp @@ -352,7 +352,8 @@ } } -TypeSystem *Module::GetTypeSystemForLanguage(LanguageType language) { +llvm::Expected +Module::GetTypeSystemForLanguage(LanguageType language) { return m_type_system_map.GetTypeSystemForLanguage(language, this, true); } Index: source/Core/ValueObjectRegister.cpp =================================================================== --- source/Core/ValueObjectRegister.cpp +++ source/Core/ValueObjectRegister.cpp @@ -256,15 +256,14 @@ 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 = - exe_module->GetTypeSystemForLanguage(eLanguageTypeC); - if (type_system) + if (auto *target = exe_ctx.GetTargetPtr()) { + if (auto *exe_module = target->GetExecutableModulePointer()) { + if (auto type_system_or_err = + exe_module->GetTypeSystemForLanguage(eLanguageTypeC)) { + auto *type_system = *type_system_or_err; m_compiler_type = type_system->GetBuiltinTypeForEncodingAndBitSize( m_reg_info.encoding, m_reg_info.byte_size * 8); + } } } } Index: source/DataFormatters/VectorType.cpp =================================================================== --- source/DataFormatters/VectorType.cpp +++ source/DataFormatters/VectorType.cpp @@ -219,13 +219,14 @@ 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()) { + if (auto type_system_or_err = + target_sp->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeC)) + type_system = *type_system_or_err; + } + 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; Index: source/Expression/Materializer.cpp =================================================================== --- source/Expression/Materializer.cpp +++ source/Expression/Materializer.cpp @@ -868,17 +868,18 @@ return; } - Status type_system_error; - TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage( - &type_system_error, m_type.GetMinimumLanguage()); - - if (!type_system) { - err.SetErrorStringWithFormat("Couldn't dematerialize a result variable: " - "couldn't get the corresponding type " - "system: %s", - type_system_error.AsCString()); + auto type_system_or_err = + target_sp->GetScratchTypeSystemForLanguage(m_type.GetMinimumLanguage()); + + if (!type_system_or_err) { + err.SetErrorStringWithFormat( + "Couldn't dematerialize a result variable: " + "couldn't get the corresponding type " + "system: %s", + llvm::toString(type_system_or_err.takeError()).c_str()); return; } + auto *type_system = *type_system_or_err; PersistentExpressionState *persistent_state = type_system->GetPersistentExpressionState(); Index: source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp =================================================================== --- source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp +++ source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp @@ -74,14 +74,16 @@ file_manager}; std::vector sources; for (lldb::ModuleSP module_sp : m_target->GetImages().Modules()) { - if (auto *module_ast_ctx = llvm::cast_or_null( - module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC))) { - 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() - }); + if (auto type_system_or_err = + module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC)) { + if (auto *module_ast_ctx = + llvm::cast_or_null(*type_system_or_err)) { + 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()}); + } } } Index: source/Plugins/Language/CPlusPlus/BlockPointer.cpp =================================================================== --- source/Plugins/Language/CPlusPlus/BlockPointer.cpp +++ source/Plugins/Language/CPlusPlus/BlockPointer.cpp @@ -39,16 +39,13 @@ 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 (!type_system_or_err) return; - } ClangASTContext *clang_ast_context = - llvm::dyn_cast(type_system); + llvm::dyn_cast(*type_system_or_err); if (!clang_ast_context) { return; Index: source/Plugins/Language/ObjC/CoreMedia.cpp =================================================================== --- source/Plugins/Language/ObjC/CoreMedia.cpp +++ source/Plugins/Language/ObjC/CoreMedia.cpp @@ -25,13 +25,13 @@ 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 (!type_system_or_err) return false; - + auto *type_system = *type_system_or_err; // fetch children by offset to compensate for potential lack of debug info auto int64_ty = type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 64); Index: source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h =================================================================== --- source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h +++ source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h @@ -122,8 +122,11 @@ size_t FindTypes(const std::vector &context, bool append, TypeMap &types) override; - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override { - return nullptr; + llvm::Expected + GetTypeSystemForLanguage(lldb::LanguageType language) override { + return llvm::make_error( + "SymbolFileBreakpad does not support GetTypeSystemForLanguage", + llvm::inconvertibleErrorCode()); } CompilerDeclContext Index: source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h =================================================================== --- source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h +++ 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 @@ llvm::Optional GetDIERef() const; - lldb_private::TypeSystem *GetTypeSystem() const; + llvm::Expected GetTypeSystem() const; DWARFASTParser *GetDWARFParser() const; Index: source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp =================================================================== --- source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp +++ source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp @@ -102,19 +102,26 @@ return nullptr; } -lldb_private::TypeSystem *DWARFBaseDIE::GetTypeSystem() const { - if (m_cu) +llvm::Expected DWARFBaseDIE::GetTypeSystem() const { + llvm::Error err = llvm::Error::success(); + if (m_cu) { + llvm::consumeError(std::move(err)); return m_cu->GetTypeSystem(); + } else - return nullptr; + err = llvm::make_error( + "Unable to get TypeSystem, no compilation unit available", + llvm::inconvertibleErrorCode()); + return std::move(err); } 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 (!type_system_or_err) return nullptr; + + auto *type_system = *type_system_or_err; + return type_system->GetDWARFParser(); } bool DWARFBaseDIE::HasChildren() const { Index: source/Plugins/SymbolFile/DWARF/DWARFUnit.h =================================================================== --- source/Plugins/SymbolFile/DWARF/DWARFUnit.h +++ source/Plugins/SymbolFile/DWARF/DWARFUnit.h @@ -153,7 +153,7 @@ lldb::ByteOrder GetByteOrder() const; - lldb_private::TypeSystem *GetTypeSystem(); + llvm::Expected GetTypeSystem(); const DWARFDebugAranges &GetFunctionAranges(); Index: source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp =================================================================== --- source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp +++ source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp @@ -438,7 +438,7 @@ return m_dwarf.GetObjectFile()->GetByteOrder(); } -TypeSystem *DWARFUnit::GetTypeSystem() { +llvm::Expected DWARFUnit::GetTypeSystem() { return m_dwarf.GetTypeSystemForLanguage(GetLanguageType()); } Index: source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h =================================================================== --- source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h +++ source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h @@ -196,7 +196,7 @@ lldb::TypeClass type_mask, lldb_private::TypeList &type_list) override; - lldb_private::TypeSystem * + llvm::Expected GetTypeSystemForLanguage(lldb::LanguageType language) override; lldb_private::CompilerDeclContext FindNamespace( Index: source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp =================================================================== --- source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp +++ source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp @@ -374,17 +374,17 @@ 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 +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() { @@ -741,17 +741,21 @@ 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; } - return nullptr; + + auto type_system_or_err = + GetTypeSystemForLanguage(die.GetCU()->GetLanguageType()); + if (!type_system_or_err) + return nullptr; + + auto *type_system = *type_system_or_err; + DWARFASTParser *dwarf_ast = type_system->GetDWARFParser(); + if (!dwarf_ast) + return nullptr; + + return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die); } bool SymbolFileDWARF::FixupAddress(Address &addr) { @@ -1188,7 +1192,9 @@ } 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 decl_ctx_die_list = ast_parser->GetDIEForDeclContext(decl_ctx); @@ -1961,9 +1967,12 @@ } 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 (!type_system_or_err) + return false; + + if (decl_ctx_type_system == *type_system_or_err) return true; // The type systems match, return true // The namespace AST was valid, and it does not match... @@ -2863,10 +2872,11 @@ // 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) { + if (auto type_system_or_err = GetTypeSystemForLanguage(language)) + type_system = *type_system_or_err; + } if (num_matches) { for (size_t i = 0; i < num_matches; ++i) { const DIERef &die_ref = die_offsets[i]; @@ -2960,11 +2970,12 @@ if (!die) return {}; - TypeSystem *type_system = + auto type_system_or_err = GetTypeSystemForLanguage(die.GetCU()->GetLanguageType()); - if (!type_system) + if (!type_system_or_err) return {}; + auto *type_system = *type_system_or_err; DWARFASTParser *dwarf_ast = type_system->GetDWARFParser(); if (!dwarf_ast) return {}; @@ -3716,8 +3727,10 @@ void SymbolFileDWARF::Dump(lldb_private::Stream &s) { m_index->Dump(s); } void SymbolFileDWARF::DumpClangAST(Stream &s) { - TypeSystem *ts = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus); - ClangASTContext *clang = llvm::dyn_cast_or_null(ts); + auto ts_or_err = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus); + if (!ts_or_err) + return; + ClangASTContext *clang = llvm::dyn_cast_or_null(*ts_or_err); if (!clang) return; clang->Dump(s); Index: source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h =================================================================== --- source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h +++ source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h @@ -30,7 +30,7 @@ size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name, DIEArray &method_die_offsets) override; - lldb_private::TypeSystem * + llvm::Expected GetTypeSystemForLanguage(lldb::LanguageType language) override; DWARFDIE Index: source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp =================================================================== --- source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp +++ source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp @@ -140,7 +140,7 @@ return DWARFExpression::SplitDwarfLocationList; } -TypeSystem * +llvm::Expected SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) { return GetBaseSymbolFile().GetTypeSystemForLanguage(language); } Index: source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp =================================================================== --- source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp +++ source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp @@ -123,7 +123,7 @@ static ClangASTContext &GetClangASTContext(ObjectFile &obj) { TypeSystem *ts = - obj.GetModule()->GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + *obj.GetModule()->GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); lldbassert(ts); return static_cast(*ts); } Index: source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h =================================================================== --- source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h +++ source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h @@ -141,7 +141,8 @@ size_t FindTypes(const std::vector &context, bool append, TypeMap &types) override; - TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override; + llvm::Expected + GetTypeSystemForLanguage(lldb::LanguageType language) override; CompilerDeclContext FindNamespace(ConstString name, Index: source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp =================================================================== --- source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp +++ source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp @@ -321,10 +321,11 @@ m_index->SetLoadAddress(m_obj_load_address); m_index->ParseSectionContribs(); - TypeSystem *ts = m_obj_file->GetModule()->GetTypeSystemForLanguage( - lldb::eLanguageTypeC_plus_plus); - if (ts) + if (auto ts_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage( + lldb::eLanguageTypeC_plus_plus)) { + auto *ts = *ts_or_err; ts->SetSymbolFile(this); + } m_ast = llvm::make_unique(*m_obj_file, *m_index); } @@ -1574,13 +1575,15 @@ return {}; } -TypeSystem * +llvm::Expected SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) { - auto type_system = + auto type_system_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage(language); - if (type_system) + if (type_system_or_err) { + auto *type_system = *type_system_or_err; type_system->SetSymbolFile(this); - return type_system; + } + return type_system_or_err; } ConstString SymbolFileNativePDB::GetPluginName() { Index: source/Plugins/SymbolFile/PDB/SymbolFilePDB.h =================================================================== --- source/Plugins/SymbolFile/PDB/SymbolFilePDB.h +++ source/Plugins/SymbolFile/PDB/SymbolFilePDB.h @@ -148,7 +148,7 @@ lldb::TypeClass type_mask, lldb_private::TypeList &type_list) override; - lldb_private::TypeSystem * + llvm::Expected GetTypeSystemForLanguage(lldb::LanguageType language) override; lldb_private::CompilerDeclContext FindNamespace( Index: source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp =================================================================== --- source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp +++ source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp @@ -302,11 +302,11 @@ 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 (!type_system_or_err) return nullptr; ClangASTContext *clang_type_system = - llvm::dyn_cast_or_null(type_system); + llvm::dyn_cast_or_null(*type_system_or_err); if (!clang_type_system) return nullptr; clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func); @@ -544,10 +544,13 @@ 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 (!type_system_or_err) + return nullptr; + ClangASTContext *clang_type_system = - llvm::dyn_cast_or_null(type_system); + llvm::dyn_cast_or_null(*type_system_or_err); if (!clang_type_system) return nullptr; PDBASTParser *pdb = clang_type_system->GetPDBParser(); @@ -577,8 +580,14 @@ std::lock_guard guard( GetObjectFile()->GetModule()->GetMutex()); - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (!type_system_or_err) + return false; + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null(*type_system_or_err); + if (!clang_ast_ctx) return false; @@ -590,8 +599,13 @@ } lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) { - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (!type_system_or_err) + return CompilerDecl(); + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null(*type_system_or_err); if (!clang_ast_ctx) return CompilerDecl(); @@ -612,8 +626,13 @@ lldb_private::CompilerDeclContext SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) { - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (!type_system_or_err) + return CompilerDeclContext(); + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null(*type_system_or_err); if (!clang_ast_ctx) return CompilerDeclContext(); @@ -634,8 +653,13 @@ lldb_private::CompilerDeclContext SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) { - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (!type_system_or_err) + return CompilerDeclContext(); + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null(*type_system_or_err); if (!clang_ast_ctx) return CompilerDeclContext(); @@ -655,8 +679,13 @@ void SymbolFilePDB::ParseDeclsForContext( lldb_private::CompilerDeclContext decl_ctx) { - ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null( - GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus)); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (!type_system_or_err) + return; + + ClangASTContext *clang_ast_ctx = + llvm::dyn_cast_or_null(*type_system_or_err); if (!clang_ast_ctx) return; @@ -1403,11 +1432,16 @@ } void SymbolFilePDB::DumpClangAST(Stream &s) { - auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); - auto clang = llvm::dyn_cast_or_null(type_system); - if (!clang) + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (!type_system_or_err) + return; + + auto *clang_type_system = + llvm::dyn_cast_or_null(*type_system_or_err); + if (!clang_type_system) return; - clang->Dump(s); + clang_type_system->Dump(s); } void SymbolFilePDB::FindTypesByRegex( @@ -1603,18 +1637,25 @@ return type_list.GetSize() - old_size; } -lldb_private::TypeSystem * +llvm::Expected SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) { - auto type_system = + auto type_system_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage(language); - if (type_system) + if (type_system_or_err) { + auto *type_system = *type_system_or_err; type_system->SetSymbolFile(this); - return type_system; + } + 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(type_system); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (!type_system_or_err) + return nullptr; + + auto *clang_type_system = + llvm::dyn_cast_or_null(*type_system_or_err); if (!clang_type_system) return nullptr; @@ -1625,8 +1666,13 @@ lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace( lldb_private::ConstString name, const lldb_private::CompilerDeclContext *parent_decl_ctx) { - auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); - auto clang_type_system = llvm::dyn_cast_or_null(type_system); + auto type_system_or_err = + GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); + if (!type_system_or_err) + return CompilerDeclContext(); + + auto *clang_type_system = + llvm::dyn_cast_or_null(*type_system_or_err); if (!clang_type_system) return CompilerDeclContext(); @@ -1644,7 +1690,7 @@ if (!namespace_decl) return CompilerDeclContext(); - return CompilerDeclContext(type_system, + return CompilerDeclContext(clang_type_system, static_cast(namespace_decl)); } @@ -1925,9 +1971,12 @@ 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 (!type_system_or_err) + return false; + + if (decl_ctx_type_system == *type_system_or_err) return true; // The type systems match, return true return false; Index: source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp =================================================================== --- source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp +++ source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp @@ -171,14 +171,21 @@ } // 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 (!type_system_or_err) { + if (log) + log->Printf("Error Inserting get-item-info function: \"%s\".", + llvm::toString(type_system_or_err.takeError()).c_str()); + return args_addr; + } + auto *type_system = *type_system_or_err; + CompilerType get_item_info_return_type = type_system->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); Index: source/Symbol/SymbolFile.cpp =================================================================== --- source/Symbol/SymbolFile.cpp +++ source/Symbol/SymbolFile.cpp @@ -86,12 +86,15 @@ return nullptr; } -TypeSystem *SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) { - TypeSystem *type_system = +llvm::Expected +SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) { + auto type_system_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage(language); - if (type_system) + if (type_system_or_err) { + auto *type_system = *type_system_or_err; type_system->SetSymbolFile(this); - return type_system; + } + return type_system_or_err; } uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec, Index: source/Symbol/Type.cpp =================================================================== --- source/Symbol/Type.cpp +++ source/Symbol/Type.cpp @@ -488,47 +488,50 @@ } } 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 (type_system_or_err) { + auto *type_system = *type_system_or_err; + CompilerType void_compiler_type = + type_system->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."); + } } } Index: source/Symbol/TypeSystem.cpp =================================================================== --- source/Symbol/TypeSystem.cpp +++ 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,138 @@ } } -TypeSystem *TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language, - Module *module, - bool can_create) { +llvm::Expected +TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language, + Module *module, bool can_create) { + llvm::Error error = llvm::Error::success(); std::lock_guard 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( + "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( + "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( + "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( + "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( + "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 +TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language, + Target *target, bool can_create) { + llvm::Error error = llvm::Error::success(); std::lock_guard 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( + "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( + "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( + "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( + "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( + "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); } Index: source/Target/StackFrame.cpp =================================================================== --- source/Target/StackFrame.cpp +++ source/Target/StackFrame.cpp @@ -1357,16 +1357,16 @@ 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) { - return ValueObjectSP(); - } else { + if (auto c_type_system_or_err = + target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC)) { + auto *c_type_system = *c_type_system_or_err; CompilerType void_ptr_type = c_type_system ->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar) .GetPointerType(); return ValueObjectMemory::Create(this, "", addr, void_ptr_type); + } else { + return ValueObjectSP(); } } else { return ValueObjectSP(); Index: source/Target/Target.cpp =================================================================== --- source/Target/Target.cpp +++ source/Target/Target.cpp @@ -2143,16 +2143,12 @@ target->SetExecutableModule(exe_module_sp, eLoadDependentsYes); } -TypeSystem *Target::GetScratchTypeSystemForLanguage(Status *error, - lldb::LanguageType language, - bool create_on_demand) { +llvm::Expected +Target::GetScratchTypeSystemForLanguage(lldb::LanguageType language, + bool create_on_demand) { if (!m_valid) return nullptr; - if (error) { - error->Clear(); - } - if (language == eLanguageTypeMipsAssembler // GNU AS and LLVM use it for all // assembly code || language == eLanguageTypeUnknown) { @@ -2180,14 +2176,13 @@ 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 (!type_system_or_err) return nullptr; - } + + auto *type_system = *type_system_or_err; + return type_system->GetPersistentExpressionState(); } UserExpression *Target::GetUserExpressionForLanguage( @@ -2195,21 +2190,17 @@ 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 (!type_system_or_err) { error.SetErrorStringWithFormat( "Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), - type_system_error.AsCString()); + llvm::toString(type_system_or_err.takeError()).c_str()); return nullptr; } + auto *type_system = *type_system_or_err; - user_expr = type_system->GetUserExpression(expr, prefix, language, + auto *user_expr = type_system->GetUserExpression(expr, prefix, language, desired_type, options, ctx_obj); if (!user_expr) error.SetErrorStringWithFormat( @@ -2223,20 +2214,17 @@ 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 (!type_system_or_err) { error.SetErrorStringWithFormat( "Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), - type_system_error.AsCString()); - return persistent_fn; + llvm::toString(type_system_or_err.takeError()).c_str()); + return nullptr; } + auto *type_system = *type_system_or_err; - persistent_fn = type_system->GetFunctionCaller(return_type, function_address, + auto *persistent_fn = type_system->GetFunctionCaller(return_type, function_address, arg_value_list, name); if (!persistent_fn) error.SetErrorStringWithFormat( @@ -2250,20 +2238,18 @@ 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 (!type_system_or_err) { error.SetErrorStringWithFormat( "Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), - type_system_error.AsCString()); - return utility_fn; + llvm::toString(type_system_or_err.takeError()).c_str()); + return nullptr; } + auto *type_system = *type_system_or_err; - utility_fn = type_system->GetUtilityFunction(text, name); + auto *utility_fn = type_system->GetUtilityFunction(text, name); if (!utility_fn) error.SetErrorStringWithFormat( "Could not create an expression for language %s", @@ -2274,9 +2260,9 @@ ClangASTContext *Target::GetScratchClangASTContext(bool create_on_demand) { if (m_valid) { - if (TypeSystem *type_system = GetScratchTypeSystemForLanguage( - nullptr, eLanguageTypeC, create_on_demand)) - return llvm::dyn_cast(type_system); + if (auto type_system_or_err = + GetScratchTypeSystemForLanguage(eLanguageTypeC, create_on_demand)) + return llvm::dyn_cast(*type_system_or_err); } return nullptr; } @@ -2373,13 +2359,16 @@ // 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] == '$') { + if (auto type_system_or_err = + GetScratchTypeSystemForLanguage(eLanguageTypeC)) { + auto *type_system = *type_system_or_err; + persistent_var_sp = + type_system->GetPersistentExpressionState()->GetVariable(expr); + } + } if (persistent_var_sp) { result_valobj_sp = persistent_var_sp->GetValueObject(); execution_results = eExpressionCompleted; Index: source/Target/ThreadPlanTracer.cpp =================================================================== --- source/Target/ThreadPlanTracer.cpp +++ source/Target/ThreadPlanTracer.cpp @@ -93,15 +93,15 @@ 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) + if (auto target_sp = m_thread.CalculateTarget()) { + if (auto type_system_or_err = + target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC)) { + auto *type_system = *type_system_or_err; m_intptr_type = TypeFromUser(type_system->GetBuiltinTypeForEncodingAndBitSize( eEncodingUint, target_sp->GetArchitecture().GetAddressByteSize() * 8)); + } } } return m_intptr_type; Index: tools/lldb-test/lldb-test.cpp =================================================================== --- tools/lldb-test/lldb-test.cpp +++ tools/lldb-test/lldb-test.cpp @@ -528,11 +528,11 @@ if (!symfile) return make_string_error("Module has no symbol file."); - auto clang_ast_ctx = llvm::dyn_cast_or_null( - symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus)); - if (!clang_ast_ctx) - return make_string_error("Can't retrieve Clang AST context."); + auto clang_ast_ctx_or_err = symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus); + if (!clang_ast_ctx_or_err) + return make_string_error("Can't retrieve ClangASTContext"); + auto clang_ast_ctx = llvm::dyn_cast_or_null(*clang_ast_ctx_or_err); auto ast_ctx = clang_ast_ctx->getASTContext(); if (!ast_ctx) return make_string_error("Can't retrieve AST context.");