xiaobai created this revision.
xiaobai added reviewers: JDevlieghere, davide, compnerd.
Herald added a subscriber: jdoerfert.
This commit achieves the following:
- Functions used to return a `TypeSystem *` return an
`llvm::Expected<TypeSystem *>` now. This means that the result of a call is
always checked, forcing clients to move more carefully.
- `TypeSystemMap::GetTypeSystemForLanguage` will either return an Error or a
non-null pointer to a TypeSystem.
https://reviews.llvm.org/D65122
Files:
include/lldb/Core/Module.h
include/lldb/Symbol/SymbolFile.h
include/lldb/Symbol/TypeSystem.h
include/lldb/Target/Target.h
source/API/SBModule.cpp
source/Breakpoint/Watchpoint.cpp
source/Core/Module.cpp
source/Core/ValueObjectRegister.cpp
source/DataFormatters/VectorType.cpp
source/Expression/Materializer.cpp
source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
source/Plugins/Language/CPlusPlus/BlockPointer.cpp
source/Plugins/Language/ObjC/CoreMedia.cpp
source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h
source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp
source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h
source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
source/Plugins/SymbolFile/DWARF/DWARFUnit.h
source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp
source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h
source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp
source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h
source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
source/Plugins/SymbolFile/PDB/SymbolFilePDB.h
source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp
source/Symbol/SymbolFile.cpp
source/Symbol/Type.cpp
source/Symbol/TypeSystem.cpp
source/Target/StackFrame.cpp
source/Target/Target.cpp
source/Target/ThreadPlanTracer.cpp
tools/lldb-test/lldb-test.cpp
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<ClangASTContext>(
- 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<ClangASTContext>(*clang_ast_ctx_or_err);
auto ast_ctx = clang_ast_ctx->getASTContext();
if (!ast_ctx)
return make_string_error("Can't retrieve AST context.");
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: 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<TypeSystem *>
+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<ClangASTContext>(type_system);
+ if (auto type_system_or_err =
+ GetScratchTypeSystemForLanguage(eLanguageTypeC, create_on_demand))
+ return llvm::dyn_cast<ClangASTContext>(*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/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/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<TypeSystem *>
+TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
+ Module *module, bool can_create) {
+ llvm::Error error = llvm::Error::success();
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();
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);
}
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/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<TypeSystem *>
+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/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/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<lldb_private::TypeSystem *>
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<ClangASTContext>(type_system);
+ llvm::dyn_cast_or_null<ClangASTContext>(*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<ClangASTContext>(type_system);
+ llvm::dyn_cast_or_null<ClangASTContext>(*type_system_or_err);
if (!clang_type_system)
return nullptr;
PDBASTParser *pdb = clang_type_system->GetPDBParser();
@@ -577,8 +580,14 @@
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 (!type_system_or_err)
+ return false;
+
+ ClangASTContext *clang_ast_ctx =
+ llvm::dyn_cast_or_null<ClangASTContext>(*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<ClangASTContext>(
- 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<ClangASTContext>(*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<ClangASTContext>(
- 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<ClangASTContext>(*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<ClangASTContext>(
- 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<ClangASTContext>(*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<ClangASTContext>(
- 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<ClangASTContext>(*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<ClangASTContext>(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<ClangASTContext>(*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<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)
+ 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<ClangASTContext>(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<ClangASTContext>(*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<ClangASTContext>(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<ClangASTContext>(*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<clang::DeclContext *>(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/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<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,
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<PdbAstBuilder>(*m_obj_file, *m_index);
}
@@ -1574,13 +1575,15 @@
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)
+ 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/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<ClangASTContext &>(*ts);
}
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<lldb_private::TypeSystem *>
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<TypeSystem *>
SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
return GetBaseSymbolFile().GetTypeSystemForLanguage(language);
}
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<lldb_private::TypeSystem *>
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<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() {
@@ -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<DWARFDIE> 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<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);
if (!clang)
return;
clang->Dump(s);
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<lldb_private::TypeSystem *> 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<TypeSystem *> DWARFUnit::GetTypeSystem() {
return m_dwarf.GetTypeSystemForLanguage(GetLanguageType());
}
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<DIERef> GetDIERef() const;
- lldb_private::TypeSystem *GetTypeSystem() const;
+ llvm::Expected<lldb_private::TypeSystem *> 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<lldb_private::TypeSystem *> 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<llvm::StringError>(
+ "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/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<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
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/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<ClangASTContext>(type_system);
+ llvm::dyn_cast<ClangASTContext>(*type_system_or_err);
if (!clang_ast_context) {
return;
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<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))) {
- 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<ClangASTContext>(*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/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/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/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/Core/Module.cpp
===================================================================
--- source/Core/Module.cpp
+++ source/Core/Module.cpp
@@ -352,7 +352,8 @@
}
}
-TypeSystem *Module::GetTypeSystemForLanguage(LanguageType language) {
+llvm::Expected<TypeSystem *>
+Module::GetTypeSystemForLanguage(LanguageType language) {
return m_type_system_map.GetTypeSystemForLanguage(language, this, true);
}
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/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: 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<TypeSystem *>
+ GetScratchTypeSystemForLanguage(lldb::LanguageType language,
+ bool create_on_demand = true);
PersistentExpressionState *
GetPersistentExpressionStateForLanguage(lldb::LanguageType language);
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<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.
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<lldb_private::TypeSystem *>
GetTypeSystemForLanguage(lldb::LanguageType language);
virtual CompilerDeclContext
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<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
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
