replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[Symbol] Use llvm::Expected when getting TypeSystems 

Summary:
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.

Reviewers: JDevlieghere, davide, compnerd

Subscribers: jdoerfert, lldb-commits

Differential Revision: https://reviews.llvm.org/D65122

llvm-svn: 367360
This commit is contained in:
Alex Langford 2019-07-30 22:12:34 +00:00
parent d56dc1d926
commit 0e252e38ef
36 changed files with 594 additions and 326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lldb/include/lldb/Core/Module.h
View File

@ -812,7 +812,8 @@ public:
bool GetIsDynamicLinkEditor();
TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language);
llvm::Expected<TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language);
// Special error functions that can do printf style formatting that will
// prepend the message with something appropriate for this module (like the

2
lldb/include/lldb/Symbol/SymbolFile.h
View File

@ -201,7 +201,7 @@ public:
virtual void PreloadSymbols();
virtual lldb_private::TypeSystem *
virtual llvm::Expected<lldb_private::TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language);
virtual CompilerDeclContext

16
lldb/include/lldb/Symbol/TypeSystem.h
View File

@ -16,6 +16,7 @@
#include "llvm/ADT/APSInt.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Error.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Expression/Expression.h"
@ -491,18 +492,15 @@ public:
// callback to keep iterating, false to stop iterating.
void ForEach(std::function<bool(TypeSystem *)> const &callback);
TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language,
Module *module, bool can_create);
llvm::Expected<TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language, Module *module,
bool can_create);
TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language,
Target *target, bool can_create);
llvm::Expected<TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language, Target *target,
bool can_create);
protected:
// This function does not take the map mutex, and should only be called from
// functions that do take the mutex.
void AddToMap(lldb::LanguageType language,
lldb::TypeSystemSP const &type_system_sp);
typedef std::map<lldb::LanguageType, lldb::TypeSystemSP> collection;
mutable std::mutex m_mutex; ///< A mutex to keep this object happy in
///multi-threaded environments.

6
lldb/include/lldb/Target/Target.h
View File

@ -1022,9 +1022,9 @@ public:
PathMappingList &GetImageSearchPathList();
TypeSystem *GetScratchTypeSystemForLanguage(Status *error,
lldb::LanguageType language,
bool create_on_demand = true);
llvm::Expected<TypeSystem &>
GetScratchTypeSystemForLanguage(lldb::LanguageType language,
bool create_on_demand = true);
PersistentExpressionState *
GetPersistentExpressionStateForLanguage(lldb::LanguageType language);

28
lldb/source/API/SBModule.cpp
View File

@ -468,10 +468,13 @@ lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match));
if (!sb_type.IsValid()) {
TypeSystem *type_system =
auto type_system_or_err =
module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
if (type_system)
sb_type = SBType(type_system->GetBuiltinTypeByName(name));
if (auto err = type_system_or_err.takeError()) {
llvm::consumeError(std::move(err));
return LLDB_RECORD_RESULT(SBType());
}
sb_type = SBType(type_system_or_err->GetBuiltinTypeByName(name));
}
}
return LLDB_RECORD_RESULT(sb_type);
@ -483,10 +486,14 @@ lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
ModuleSP module_sp(GetSP());
if (module_sp) {
TypeSystem *type_system =
auto type_system_or_err =
module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
if (type_system)
return LLDB_RECORD_RESULT(SBType(type_system->GetBasicTypeFromAST(type)));
if (auto err = type_system_or_err.takeError()) {
llvm::consumeError(std::move(err));
} else {
return LLDB_RECORD_RESULT(
SBType(type_system_or_err->GetBasicTypeFromAST(type)));
}
}
return LLDB_RECORD_RESULT(SBType());
}
@ -513,10 +520,13 @@ lldb::SBTypeList SBModule::FindTypes(const char *type) {
retval.Append(SBType(type_sp));
}
} else {
TypeSystem *type_system =
auto type_system_or_err =
module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
if (type_system) {
CompilerType compiler_type = type_system->GetBuiltinTypeByName(name);
if (auto err = type_system_or_err.takeError()) {
llvm::consumeError(std::move(err));
} else {
CompilerType compiler_type =
type_system_or_err->GetBuiltinTypeByName(name);
if (compiler_type)
retval.Append(SBType(compiler_type));
}

16
lldb/source/Breakpoint/Watchpoint.cpp
View File

@ -17,6 +17,7 @@
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h"
using namespace lldb;
@ -30,15 +31,22 @@ Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
m_watch_write(0), m_watch_was_read(0), m_watch_was_written(0),
m_ignore_count(0), m_false_alarms(0), m_decl_str(), m_watch_spec_str(),
m_type(), m_error(), m_options(), m_being_created(true) {
if (type && type->IsValid())
m_type = *type;
else {
// If we don't have a known type, then we force it to unsigned int of the
// right size.
TypeSystem *ast_context =
target.GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint,
8 * size);
auto type_system_or_err =
target.GetScratchTypeSystemForLanguage(eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS),
std::move(err), "Failed to set type.");
} else {
m_type = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
eEncodingUint, 8 * size);
}
}
// Set the initial value of the watched variable:

3
lldb/source/Core/Module.cpp
View File

@ -353,7 +353,8 @@ void Module::SetUUID(const lldb_private::UUID &uuid) {
}
}
TypeSystem *Module::GetTypeSystemForLanguage(LanguageType language) {
llvm::Expected<TypeSystem &>
Module::GetTypeSystemForLanguage(LanguageType language) {
return m_type_system_map.GetTypeSystemForLanguage(language, this, true);
}

21
lldb/source/Core/ValueObjectRegister.cpp
View File

@ -18,6 +18,7 @@
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Scalar.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
@ -256,15 +257,19 @@ ValueObjectRegister::~ValueObjectRegister() {}
CompilerType ValueObjectRegister::GetCompilerTypeImpl() {
if (!m_compiler_type.IsValid()) {
ExecutionContext exe_ctx(GetExecutionContextRef());
Target *target = exe_ctx.GetTargetPtr();
if (target) {
Module *exe_module = target->GetExecutableModulePointer();
if (exe_module) {
TypeSystem *type_system =
if (auto *target = exe_ctx.GetTargetPtr()) {
if (auto *exe_module = target->GetExecutableModulePointer()) {
auto type_system_or_err =
exe_module->GetTypeSystemForLanguage(eLanguageTypeC);
if (type_system)
m_compiler_type = type_system->GetBuiltinTypeForEncodingAndBitSize(
m_reg_info.encoding, m_reg_info.byte_size * 8);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TYPES),
std::move(err), "Unable to get CompilerType from TypeSystem");
} else {
m_compiler_type =
type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
m_reg_info.encoding, m_reg_info.byte_size * 8);
}
}
}
}

22
lldb/source/DataFormatters/VectorType.cpp
View File

@ -15,6 +15,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Log.h"
using namespace lldb;
using namespace lldb_private;
@ -219,13 +220,20 @@ public:
CompilerType parent_type(m_backend.GetCompilerType());
CompilerType element_type;
parent_type.IsVectorType(&element_type, nullptr);
TargetSP target_sp(m_backend.GetTargetSP());
m_child_type = ::GetCompilerTypeForFormat(
m_parent_format, element_type,
target_sp
? target_sp->GetScratchTypeSystemForLanguage(nullptr,
lldb::eLanguageTypeC)
: nullptr);
TypeSystem *type_system = nullptr;
if (auto target_sp = m_backend.GetTargetSP()) {
auto type_system_or_err =
target_sp->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS),
std::move(err), "Unable to update from scratch TypeSystem");
} else {
type_system = &type_system_or_err.get();
}
}
m_child_type =
::GetCompilerTypeForFormat(m_parent_format, element_type, type_system);
m_num_children = ::CalculateNumChildren(parent_type, m_child_type);
m_item_format = GetItemFormatForFormat(m_parent_format, m_child_type);
return false;

12
lldb/source/Expression/Materializer.cpp
View File

@ -869,20 +869,18 @@ public:
return;
}
Status type_system_error;
TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage(
&type_system_error, m_type.GetMinimumLanguage());
auto type_system_or_err =
target_sp->GetScratchTypeSystemForLanguage(m_type.GetMinimumLanguage());
if (!type_system) {
if (auto error = type_system_or_err.takeError()) {
err.SetErrorStringWithFormat("Couldn't dematerialize a result variable: "
"couldn't get the corresponding type "
"system: %s",
type_system_error.AsCString());
llvm::toString(std::move(error)).c_str());
return;
}
PersistentExpressionState *persistent_state =
type_system->GetPersistentExpressionState();
type_system_or_err->GetPersistentExpressionState();
if (!persistent_state) {
err.SetErrorString("Couldn't dematerialize a result variable: "

13
lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
View File

@ -74,14 +74,19 @@ void ClangASTSource::InstallASTContext(clang::ASTContext &ast_context,
file_manager};
std::vector<clang::ExternalASTMerger::ImporterSource> sources;
for (lldb::ModuleSP module_sp : m_target->GetImages().Modules()) {
if (auto *module_ast_ctx = llvm::cast_or_null<ClangASTContext>(
module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC))) {
auto type_system_or_err =
module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS),
std::move(err), "Failed to get ClangASTContext");
} else if (auto *module_ast_ctx = llvm::cast_or_null<ClangASTContext>(
&type_system_or_err.get())) {
lldbassert(module_ast_ctx->getASTContext());
lldbassert(module_ast_ctx->getFileManager());
sources.push_back({*module_ast_ctx->getASTContext(),
*module_ast_ctx->getFileManager(),
module_ast_ctx->GetOriginMap()
});
module_ast_ctx->GetOriginMap()});
}
}

14
lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp
View File

@ -17,6 +17,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Log.h"
using namespace lldb;
using namespace lldb_private;
@ -39,16 +40,17 @@ public:
return;
}
Status err;
TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage(
&err, lldb::eLanguageTypeC_plus_plus);
if (!err.Success() || !type_system) {
auto type_system_or_err = target_sp->GetScratchTypeSystemForLanguage(
lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS),
std::move(err), "Failed to get scratch ClangASTContext");
return;
}
ClangASTContext *clang_ast_context =
llvm::dyn_cast<ClangASTContext>(type_system);
llvm::dyn_cast<ClangASTContext>(&type_system_or_err.get());
if (!clang_ast_context) {
return;

20
lldb/source/Plugins/Language/ObjC/CoreMedia.cpp
View File

@ -10,6 +10,7 @@
#include "CoreMedia.h"
#include "lldb/Utility/Flags.h"
#include "lldb/Utility/Log.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/Target.h"
@ -25,18 +26,21 @@ bool lldb_private::formatters::CMTimeSummaryProvider(
if (!type.IsValid())
return false;
TypeSystem *type_system =
auto type_system_or_err =
valobj.GetExecutionContextRef()
.GetTargetSP()
->GetScratchTypeSystemForLanguage(nullptr, lldb::eLanguageTypeC);
if (!type_system)
->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS),
std::move(err), "Failed to get scratch type system");
return false;
}
// fetch children by offset to compensate for potential lack of debug info
auto int64_ty =
type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 64);
auto int32_ty =
type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 32);
auto int64_ty = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
eEncodingSint, 64);
auto int32_ty = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
eEncodingSint, 32);
auto value_sp(valobj.GetSyntheticChildAtOffset(0, int64_ty, true));
auto timescale_sp(valobj.GetSyntheticChildAtOffset(8, int32_ty, true));

7
lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h
View File

@ -118,8 +118,11 @@ public:
size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
TypeMap &types) override;
TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override {
return nullptr;
llvm::Expected<TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language) override {
return llvm::make_error<llvm::StringError>(
"SymbolFileBreakpad does not support GetTypeSystemForLanguage",
llvm::inconvertibleErrorCode());
}
CompilerDeclContext

22
lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp
View File

@ -14,6 +14,7 @@
#include "lldb/Core/Module.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/Log.h"
using namespace lldb_private;
@ -102,19 +103,22 @@ SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const {
return nullptr;
}
lldb_private::TypeSystem *DWARFBaseDIE::GetTypeSystem() const {
if (m_cu)
return m_cu->GetTypeSystem();
else
return nullptr;
llvm::Expected<lldb_private::TypeSystem &> DWARFBaseDIE::GetTypeSystem() const {
if (!m_cu)
return llvm::make_error<llvm::StringError>(
"Unable to get TypeSystem, no compilation unit available",
llvm::inconvertibleErrorCode());
return m_cu->GetTypeSystem();
}
DWARFASTParser *DWARFBaseDIE::GetDWARFParser() const {
lldb_private::TypeSystem *type_system = GetTypeSystem();
if (type_system)
return type_system->GetDWARFParser();
else
auto type_system_or_err = GetTypeSystem();
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to get DWARFASTParser");
return nullptr;
}
return type_system_or_err->GetDWARFParser();
}
bool DWARFBaseDIE::HasChildren() const {

4
lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h
View File

@ -12,6 +12,8 @@
#include "lldb/Core/dwarf.h"
#include "lldb/lldb-types.h"
#include "llvm/Support/Error.h"
class DIERef;
class DWARFASTParser;
class DWARFAttributes;
@ -55,7 +57,7 @@ public:
llvm::Optional<DIERef> GetDIERef() const;
lldb_private::TypeSystem *GetTypeSystem() const;
llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem() const;
DWARFASTParser *GetDWARFParser() const;

2
lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
View File

@ -438,7 +438,7 @@ lldb::ByteOrder DWARFUnit::GetByteOrder() const {
return m_dwarf.GetObjectFile()->GetByteOrder();
}
TypeSystem *DWARFUnit::GetTypeSystem() {
llvm::Expected<TypeSystem &> DWARFUnit::GetTypeSystem() {
return m_dwarf.GetTypeSystemForLanguage(GetLanguageType());
}

2
lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h
View File

@ -153,7 +153,7 @@ public:
lldb::ByteOrder GetByteOrder() const;
lldb_private::TypeSystem *GetTypeSystem();
llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem();
const DWARFDebugAranges &GetFunctionAranges();

88
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
View File

@ -364,17 +364,17 @@ UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
return m_unique_ast_type_map;
}
TypeSystem *SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
TypeSystem *type_system;
if (debug_map_symfile) {
type_system = debug_map_symfile->GetTypeSystemForLanguage(language);
} else {
type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
if (type_system)
type_system->SetSymbolFile(this);
llvm::Expected<TypeSystem &>
SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
return debug_map_symfile->GetTypeSystemForLanguage(language);
auto type_system_or_err =
m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
if (type_system_or_err) {
type_system_or_err->SetSymbolFile(this);
}
return type_system;
return type_system_or_err;
}
void SymbolFileDWARF::InitializeObject() {
@ -730,17 +730,21 @@ CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) {
Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
const DWARFDIE &die) {
ASSERT_MODULE_LOCK(this);
if (die.IsValid()) {
TypeSystem *type_system =
GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
if (!die.IsValid())
return nullptr;
if (type_system) {
DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
if (dwarf_ast)
return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die);
}
auto type_system_or_err =
GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to parse function");
return nullptr;
}
return nullptr;
DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
if (!dwarf_ast)
return nullptr;
return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die);
}
bool SymbolFileDWARF::FixupAddress(Address &addr) {
@ -1177,7 +1181,9 @@ bool SymbolFileDWARF::ClassOrStructIsVirtual(const DWARFDIE &parent_die) {
}
void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
TypeSystem *type_system = decl_ctx.GetTypeSystem();
auto *type_system = decl_ctx.GetTypeSystem();
if (!type_system)
return;
DWARFASTParser *ast_parser = type_system->GetDWARFParser();
std::vector<DWARFDIE> decl_ctx_die_list =
ast_parser->GetDIEForDeclContext(decl_ctx);
@ -1948,9 +1954,16 @@ bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
}
TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
TypeSystem *type_system = GetTypeSystemForLanguage(
auto type_system_or_err = GetTypeSystemForLanguage(
decl_ctx_type_system->GetMinimumLanguage(nullptr));
if (decl_ctx_type_system == type_system)
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err),
"Unable to match namespace decl using TypeSystem");
return false;
}
if (decl_ctx_type_system == &type_system_or_err.get())
return true; // The type systems match, return true
// The namespace AST was valid, and it does not match...
@ -2857,10 +2870,18 @@ TypeSP SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(
// use this to ensure any matches we find are in a language that this
// type system supports
const LanguageType language = dwarf_decl_ctx.GetLanguage();
TypeSystem *type_system = (language == eLanguageTypeUnknown)
? nullptr
: GetTypeSystemForLanguage(language);
TypeSystem *type_system = nullptr;
if (language != eLanguageTypeUnknown) {
auto type_system_or_err = GetTypeSystemForLanguage(language);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Cannot get TypeSystem for language {}",
Language::GetNameForLanguageType(language));
} else {
type_system = &type_system_or_err.get();
}
}
if (num_matches) {
for (size_t i = 0; i < num_matches; ++i) {
const DIERef &die_ref = die_offsets[i];
@ -2954,12 +2975,15 @@ TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
if (!die)
return {};
TypeSystem *type_system =
auto type_system_or_err =
GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
if (!type_system)
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to parse type");
return {};
}
DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
if (!dwarf_ast)
return {};
@ -3711,8 +3735,10 @@ void SymbolFileDWARF::Dump(lldb_private::Stream &s) {
}
void SymbolFileDWARF::DumpClangAST(Stream &s) {
TypeSystem *ts = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
ClangASTContext *clang = llvm::dyn_cast_or_null<ClangASTContext>(ts);
auto ts_or_err = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
if (!ts_or_err)
return;
ClangASTContext *clang = llvm::dyn_cast_or_null<ClangASTContext>(&ts_or_err.get());
if (!clang)
return;
clang->Dump(s);

2
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
View File

@ -191,7 +191,7 @@ public:
lldb::TypeClass type_mask,
lldb_private::TypeList &type_list) override;
lldb_private::TypeSystem *
llvm::Expected<lldb_private::TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language) override;
lldb_private::CompilerDeclContext FindNamespace(

2
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp
View File

@ -140,7 +140,7 @@ SymbolFileDWARFDwo::GetLocationListFormat() const {
return DWARFExpression::SplitDwarfLocationList;
}
TypeSystem *
llvm::Expected<TypeSystem &>
SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
return GetBaseSymbolFile().GetTypeSystemForLanguage(language);
}

2
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h
View File

@ -30,7 +30,7 @@ public:
size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
DIEArray &method_die_offsets) override;
lldb_private::TypeSystem *
llvm::Expected<lldb_private::TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language) override;
DWARFDIE

11
lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp
View File

@ -121,13 +121,6 @@ AnyScopesHaveTemplateParams(llvm::ArrayRef<llvm::ms_demangle::Node *> scopes) {
return false;
}
static ClangASTContext &GetClangASTContext(ObjectFile &obj) {
TypeSystem *ts =
obj.GetModule()->GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
lldbassert(ts);
return static_cast<ClangASTContext &>(*ts);
}
static llvm::Optional<clang::CallingConv>
TranslateCallingConvention(llvm::codeview::CallingConvention conv) {
using CC = llvm::codeview::CallingConvention;
@ -209,8 +202,8 @@ static bool IsAnonymousNamespaceName(llvm::StringRef name) {
return name == "`anonymous namespace'" || name == "`anonymous-namespace'";
}
PdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index)
: m_index(index), m_clang(GetClangASTContext(obj)) {
PdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index, ClangASTContext &clang)
: m_index(index), m_clang(clang) {
BuildParentMap();
}

2
lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h
View File

@ -51,7 +51,7 @@ struct DeclStatus {
class PdbAstBuilder {
public:
// Constructors and Destructors
PdbAstBuilder(ObjectFile &obj, PdbIndex &index);
PdbAstBuilder(ObjectFile &obj, PdbIndex &index, ClangASTContext &clang);
lldb_private::CompilerDeclContext GetTranslationUnitDecl();

27
lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
View File

@ -30,6 +30,7 @@
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Utility/Log.h"
#include "llvm/DebugInfo/CodeView/CVRecord.h"
#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
@ -321,12 +322,17 @@ void SymbolFileNativePDB::InitializeObject() {
m_index->SetLoadAddress(m_obj_load_address);
m_index->ParseSectionContribs();
TypeSystem *ts = m_obj_file->GetModule()->GetTypeSystemForLanguage(
auto ts_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage(
lldb::eLanguageTypeC_plus_plus);
if (ts)
ts->SetSymbolFile(this);
m_ast = llvm::make_unique<PdbAstBuilder>(*m_obj_file, *m_index);
if (auto err = ts_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Failed to initialize");
} else {
ts_or_err->SetSymbolFile(this);
auto *clang = llvm::cast_or_null<ClangASTContext>(&ts_or_err.get());
lldbassert(clang);
m_ast = llvm::make_unique<PdbAstBuilder>(*m_obj_file, *m_index, *clang);
}
}
uint32_t SymbolFileNativePDB::CalculateNumCompileUnits() {
@ -1585,13 +1591,14 @@ SymbolFileNativePDB::FindNamespace(ConstString name,
return {};
}
TypeSystem *
llvm::Expected<TypeSystem &>
SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
auto type_system =
auto type_system_or_err =
m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
if (type_system)
type_system->SetSymbolFile(this);
return type_system;
if (type_system_or_err) {
type_system_or_err->SetSymbolFile(this);
}
return type_system_or_err;
}
ConstString SymbolFileNativePDB::GetPluginName() {

3
lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h
View File

@ -137,7 +137,8 @@ public:
size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
TypeMap &types) override;
TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override;
llvm::Expected<TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language) override;
CompilerDeclContext
FindNamespace(ConstString name,

148
lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
View File

@ -24,6 +24,7 @@
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/TypeMap.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/RegularExpression.h"
#include "llvm/DebugInfo/PDB/GenericError.h"
@ -299,11 +300,15 @@ SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
comp_unit.AddFunction(func_sp);
LanguageType lang = ParseLanguage(comp_unit);
TypeSystem *type_system = GetTypeSystemForLanguage(lang);
if (!type_system)
auto type_system_or_err = GetTypeSystemForLanguage(lang);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to parse PDBFunc");
return nullptr;
}
ClangASTContext *clang_type_system =
llvm::dyn_cast_or_null<ClangASTContext>(type_system);
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_type_system)
return nullptr;
clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func);
@ -548,10 +553,16 @@ lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
if (find_result != m_types.end())
return find_result->second.get();
TypeSystem *type_system =
auto type_system_or_err =
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to ResolveTypeUID");
return nullptr;
}
ClangASTContext *clang_type_system =
llvm::dyn_cast_or_null<ClangASTContext>(type_system);
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_type_system)
return nullptr;
PDBASTParser *pdb = clang_type_system->GetPDBParser();
@ -579,8 +590,17 @@ bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
std::lock_guard<std::recursive_mutex> guard(
GetObjectFile()->GetModule()->GetMutex());
ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
auto type_system_or_err =
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to get dynamic array info for UID");
return false;
}
ClangASTContext *clang_ast_ctx =
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_ast_ctx)
return false;
@ -592,8 +612,16 @@ bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
}
lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
auto type_system_or_err =
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to get decl for UID");
return CompilerDecl();
}
ClangASTContext *clang_ast_ctx =
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_ast_ctx)
return CompilerDecl();
@ -614,8 +642,16 @@ lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
lldb_private::CompilerDeclContext
SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
auto type_system_or_err =
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to get DeclContext for UID");
return CompilerDeclContext();
}
ClangASTContext *clang_ast_ctx =
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_ast_ctx)
return CompilerDeclContext();
@ -636,8 +672,16 @@ SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
lldb_private::CompilerDeclContext
SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
auto type_system_or_err =
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to get DeclContext containing UID");
return CompilerDeclContext();
}
ClangASTContext *clang_ast_ctx =
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_ast_ctx)
return CompilerDeclContext();
@ -657,8 +701,16 @@ SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
void SymbolFilePDB::ParseDeclsForContext(
lldb_private::CompilerDeclContext decl_ctx) {
ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
auto type_system_or_err =
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to parse decls for context");
return;
}
ClangASTContext *clang_ast_ctx =
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_ast_ctx)
return;
@ -1412,11 +1464,19 @@ uint32_t SymbolFilePDB::FindTypes(
}
void SymbolFilePDB::DumpClangAST(Stream &s) {
auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
auto clang = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
if (!clang)
auto type_system_or_err =
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to dump ClangAST");
return;
clang->Dump(s);
}
auto *clang_type_system =
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_type_system)
return;
clang_type_system->Dump(s);
}
void SymbolFilePDB::FindTypesByRegex(
@ -1609,18 +1669,27 @@ size_t SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
return type_list.GetSize() - old_size;
}
lldb_private::TypeSystem *
llvm::Expected<lldb_private::TypeSystem &>
SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
auto type_system =
auto type_system_or_err =
m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
if (type_system)
type_system->SetSymbolFile(this);
return type_system;
if (type_system_or_err) {
type_system_or_err->SetSymbolFile(this);
}
return type_system_or_err;
}
PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
auto type_system_or_err =
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to get PDB AST parser");
return nullptr;
}
auto *clang_type_system =
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_type_system)
return nullptr;
@ -1632,8 +1701,17 @@ lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
auto type_system_or_err =
GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to find namespace {}",
name.AsCString());
return CompilerDeclContext();
}
auto *clang_type_system =
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_type_system)
return CompilerDeclContext();
@ -1651,7 +1729,7 @@ lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
if (!namespace_decl)
return CompilerDeclContext();
return CompilerDeclContext(type_system,
return CompilerDeclContext(clang_type_system,
static_cast<clang::DeclContext *>(namespace_decl));
}
@ -1931,9 +2009,17 @@ bool SymbolFilePDB::DeclContextMatchesThisSymbolFile(
TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
if (!decl_ctx_type_system)
return false;
TypeSystem *type_system = GetTypeSystemForLanguage(
auto type_system_or_err = GetTypeSystemForLanguage(
decl_ctx_type_system->GetMinimumLanguage(nullptr));
if (decl_ctx_type_system == type_system)
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err),
"Unable to determine if DeclContext matches this symbol file");
return false;
}
if (decl_ctx_type_system == &type_system_or_err.get())
return true; // The type systems match, return true
return false;

2
lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h
View File

@ -142,7 +142,7 @@ public:
lldb::TypeClass type_mask,
lldb_private::TypeList &type_list) override;
lldb_private::TypeSystem *
llvm::Expected<lldb_private::TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language) override;
lldb_private::CompilerDeclContext FindNamespace(

15
lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp
View File

@ -169,14 +169,19 @@ lldb::addr_t AppleGetItemInfoHandler::SetupGetItemInfoFunction(
}
// Next make the runner function for our implementation utility function.
Status error;
TypeSystem *type_system =
auto type_system_or_err =
thread.GetProcess()->GetTarget().GetScratchTypeSystemForLanguage(
nullptr, eLanguageTypeC);
eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(log, std::move(err),
"Error inseting get-item-info function");
return args_addr;
}
CompilerType get_item_info_return_type =
type_system->GetBasicTypeFromAST(eBasicTypeVoid).GetPointerType();
type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid)
.GetPointerType();
Status error;
get_item_info_caller = m_get_item_info_impl_code->MakeFunctionCaller(
get_item_info_return_type, get_item_info_arglist,
thread.shared_from_this(), error);

12
lldb/source/Symbol/SymbolFile.cpp
View File

@ -85,12 +85,14 @@ SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) {
return best_symfile_up.release();
}
TypeSystem *SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) {
TypeSystem *type_system =
llvm::Expected<TypeSystem &>
SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) {
auto type_system_or_err =
m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
if (type_system)
type_system->SetSymbolFile(this);
return type_system;
if (type_system_or_err) {
type_system_or_err->SetSymbolFile(this);
}
return type_system_or_err;
}
uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec,

72
lldb/source/Symbol/Type.cpp
View File

@ -11,6 +11,7 @@
#include "lldb/Core/Module.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Scalar.h"
#include "lldb/Utility/StreamString.h"
@ -486,47 +487,54 @@ bool Type::ResolveClangType(ResolveState compiler_type_resolve_state) {
}
} else {
// We have no encoding type, return void?
TypeSystem *type_system =
auto type_system_or_err =
m_symbol_file->GetTypeSystemForLanguage(eLanguageTypeC);
CompilerType void_compiler_type =
type_system->GetBasicTypeFromAST(eBasicTypeVoid);
switch (m_encoding_uid_type) {
case eEncodingIsUID:
m_compiler_type = void_compiler_type;
break;
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err),
"Unable to construct void type from ClangASTContext");
} else {
CompilerType void_compiler_type =
type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid);
switch (m_encoding_uid_type) {
case eEncodingIsUID:
m_compiler_type = void_compiler_type;
break;
case eEncodingIsConstUID:
m_compiler_type = void_compiler_type.AddConstModifier();
break;
case eEncodingIsConstUID:
m_compiler_type = void_compiler_type.AddConstModifier();
break;
case eEncodingIsRestrictUID:
m_compiler_type = void_compiler_type.AddRestrictModifier();
break;
case eEncodingIsRestrictUID:
m_compiler_type = void_compiler_type.AddRestrictModifier();
break;
case eEncodingIsVolatileUID:
m_compiler_type = void_compiler_type.AddVolatileModifier();
break;
case eEncodingIsVolatileUID:
m_compiler_type = void_compiler_type.AddVolatileModifier();
break;
case eEncodingIsTypedefUID:
m_compiler_type = void_compiler_type.CreateTypedef(
m_name.AsCString("__lldb_invalid_typedef_name"),
GetSymbolFile()->GetDeclContextContainingUID(GetID()));
break;
case eEncodingIsTypedefUID:
m_compiler_type = void_compiler_type.CreateTypedef(
m_name.AsCString("__lldb_invalid_typedef_name"),
GetSymbolFile()->GetDeclContextContainingUID(GetID()));
break;
case eEncodingIsPointerUID:
m_compiler_type = void_compiler_type.GetPointerType();
break;
case eEncodingIsPointerUID:
m_compiler_type = void_compiler_type.GetPointerType();
break;
case eEncodingIsLValueReferenceUID:
m_compiler_type = void_compiler_type.GetLValueReferenceType();
break;
case eEncodingIsLValueReferenceUID:
m_compiler_type = void_compiler_type.GetLValueReferenceType();
break;
case eEncodingIsRValueReferenceUID:
m_compiler_type = void_compiler_type.GetRValueReferenceType();
break;
case eEncodingIsRValueReferenceUID:
m_compiler_type = void_compiler_type.GetRValueReferenceType();
break;
default:
llvm_unreachable("Unhandled encoding_data_type.");
default:
llvm_unreachable("Unhandled encoding_data_type.");
}
}
}

172
lldb/source/Symbol/TypeSystem.cpp
View File

@ -20,6 +20,7 @@
#include "lldb/Core/PluginManager.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/Language.h"
using namespace lldb_private;
using namespace lldb;
@ -198,65 +199,140 @@ void TypeSystemMap::ForEach(std::function<bool(TypeSystem *)> const &callback) {
}
}
TypeSystem *TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
Module *module,
bool can_create) {
llvm::Expected<TypeSystem &>
TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
Module *module, bool can_create) {
llvm::Error error = llvm::Error::success();
assert(!error); // Check the success value when assertions are enabled
std::lock_guard<std::mutex> guard(m_mutex);
collection::iterator pos = m_map.find(language);
if (pos != m_map.end())
return pos->second.get();
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
AddToMap(language, pair.second);
return pair.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
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) {
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());
}
}
if (!can_create)
return nullptr;
// Cache even if we get a shared pointer that contains null type system back
lldb::TypeSystemSP type_system_sp =
TypeSystem::CreateInstance(language, module);
AddToMap(language, type_system_sp);
return type_system_sp.get();
return std::move(error);
}
TypeSystem *TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
Target *target,
bool can_create) {
llvm::Expected<TypeSystem &>
TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
Target *target, bool can_create) {
llvm::Error error = llvm::Error::success();
assert(!error); // Check the success value when assertions are enabled
std::lock_guard<std::mutex> guard(m_mutex);
collection::iterator pos = m_map.find(language);
if (pos != m_map.end())
return pos->second.get();
if (m_clear_in_progress) {
error = llvm::make_error<llvm::StringError>(
"Unable to get TypeSystem because TypeSystemMap is being cleared",
llvm::inconvertibleErrorCode());
} else {
collection::iterator pos = m_map.find(language);
if (pos != m_map.end()) {
auto *type_system = pos->second.get();
if (type_system) {
llvm::consumeError(std::move(error));
return *type_system;
}
error = llvm::make_error<llvm::StringError>(
"TypeSystem for language " +
llvm::toStringRef(Language::GetNameForLanguageType(language)) +
" doesn't exist",
llvm::inconvertibleErrorCode());
return std::move(error);
}
for (const auto &pair : m_map) {
if (pair.second && pair.second->SupportsLanguage(language)) {
// Add a new mapping for "language" to point to an already existing
// TypeSystem that supports this language
for (const auto &pair : m_map) {
if (pair.second && pair.second->SupportsLanguage(language)) {
// Add a new mapping for "language" to point to an already existing
// TypeSystem that supports this language
m_map[language] = pair.second;
if (pair.second.get()) {
llvm::consumeError(std::move(error));
return *pair.second.get();
}
error = llvm::make_error<llvm::StringError>(
"TypeSystem for language " +
llvm::toStringRef(Language::GetNameForLanguageType(language)) +
" doesn't exist",
llvm::inconvertibleErrorCode());
return std::move(error);
}
}
AddToMap(language, pair.second);
return pair.second.get();
if (!can_create) {
error = llvm::make_error<llvm::StringError>(
"Unable to find type system for language " +
llvm::toStringRef(Language::GetNameForLanguageType(language)),
llvm::inconvertibleErrorCode());
} else {
// Cache even if we get a shared pointer that contains a null type system
// back
auto type_system_sp = TypeSystem::CreateInstance(language, target);
m_map[language] = type_system_sp;
if (type_system_sp.get()) {
llvm::consumeError(std::move(error));
return *type_system_sp.get();
}
error = llvm::make_error<llvm::StringError>(
"TypeSystem for language " +
llvm::toStringRef(Language::GetNameForLanguageType(language)) +
" doesn't exist",
llvm::inconvertibleErrorCode());
}
}
if (!can_create)
return nullptr;
// Cache even if we get a shared pointer that contains null type system back
lldb::TypeSystemSP type_system_sp;
if (!m_clear_in_progress)
type_system_sp = TypeSystem::CreateInstance(language, target);
AddToMap(language, type_system_sp);
return type_system_sp.get();
}
void TypeSystemMap::AddToMap(lldb::LanguageType language,
lldb::TypeSystemSP const &type_system_sp) {
if (!m_clear_in_progress)
m_map[language] = type_system_sp;
return std::move(error);
}

12
lldb/source/Target/StackFrame.cpp
View File

@ -29,6 +29,7 @@
#include "lldb/Target/StackFrameRecognizer.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/RegisterValue.h"
#include "lldb/lldb-enumerations.h"
@ -1357,13 +1358,16 @@ lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) {
if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate +
base_and_offset.second,
addr)) {
TypeSystem *c_type_system =
target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
if (!c_type_system) {
auto c_type_system_or_err =
target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
if (auto err = c_type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD),
std::move(err), "Unable to guess value for given address");
return ValueObjectSP();
} else {
CompilerType void_ptr_type =
c_type_system
c_type_system_or_err
->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar)
.GetPointerType();
return ValueObjectMemory::Create(this, "", addr, void_ptr_type);

107
lldb/source/Target/Target.cpp
View File

@ -2119,15 +2119,12 @@ void Target::ImageSearchPathsChanged(const PathMappingList &path_list,
target->SetExecutableModule(exe_module_sp, eLoadDependentsYes);
}
TypeSystem *Target::GetScratchTypeSystemForLanguage(Status *error,
lldb::LanguageType language,
bool create_on_demand) {
llvm::Expected<TypeSystem &>
Target::GetScratchTypeSystemForLanguage(lldb::LanguageType language,
bool create_on_demand) {
if (!m_valid)
return nullptr;
if (error) {
error->Clear();
}
return llvm::make_error<llvm::StringError>("Invalid Target",
llvm::inconvertibleErrorCode());
if (language == eLanguageTypeMipsAssembler // GNU AS and LLVM use it for all
// assembly code
@ -2143,7 +2140,9 @@ TypeSystem *Target::GetScratchTypeSystemForLanguage(Status *error,
// target language.
} else {
if (languages_for_expressions.empty()) {
return nullptr;
return llvm::make_error<llvm::StringError>(
"No expression support for any languages",
llvm::inconvertibleErrorCode());
} else {
language = *languages_for_expressions.begin();
}
@ -2156,14 +2155,17 @@ TypeSystem *Target::GetScratchTypeSystemForLanguage(Status *error,
PersistentExpressionState *
Target::GetPersistentExpressionStateForLanguage(lldb::LanguageType language) {
TypeSystem *type_system =
GetScratchTypeSystemForLanguage(nullptr, language, true);
auto type_system_or_err = GetScratchTypeSystemForLanguage(language, true);
if (type_system) {
return type_system->GetPersistentExpressionState();
} else {
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),
std::move(err),
"Unable to get persistent expression state for language {}",
Language::GetNameForLanguageType(language));
return nullptr;
}
return type_system_or_err->GetPersistentExpressionState();
}
UserExpression *Target::GetUserExpressionForLanguage(
@ -2171,22 +2173,17 @@ UserExpression *Target::GetUserExpressionForLanguage(
Expression::ResultType desired_type,
const EvaluateExpressionOptions &options, ValueObject *ctx_obj,
Status &error) {
Status type_system_error;
TypeSystem *type_system =
GetScratchTypeSystemForLanguage(&type_system_error, language);
UserExpression *user_expr = nullptr;
if (!type_system) {
auto type_system_or_err = GetScratchTypeSystemForLanguage(language);
if (auto err = type_system_or_err.takeError()) {
error.SetErrorStringWithFormat(
"Could not find type system for language %s: %s",
Language::GetNameForLanguageType(language),
type_system_error.AsCString());
llvm::toString(std::move(err)).c_str());
return nullptr;
}
user_expr = type_system->GetUserExpression(expr, prefix, language,
desired_type, options, ctx_obj);
auto *user_expr = type_system_or_err->GetUserExpression(
expr, prefix, language, desired_type, options, ctx_obj);
if (!user_expr)
error.SetErrorStringWithFormat(
"Could not create an expression for language %s",
@ -2199,21 +2196,17 @@ FunctionCaller *Target::GetFunctionCallerForLanguage(
lldb::LanguageType language, const CompilerType &return_type,
const Address &function_address, const ValueList &arg_value_list,
const char *name, Status &error) {
Status type_system_error;
TypeSystem *type_system =
GetScratchTypeSystemForLanguage(&type_system_error, language);
FunctionCaller *persistent_fn = nullptr;
if (!type_system) {
auto type_system_or_err = GetScratchTypeSystemForLanguage(language);
if (auto err = type_system_or_err.takeError()) {
error.SetErrorStringWithFormat(
"Could not find type system for language %s: %s",
Language::GetNameForLanguageType(language),
type_system_error.AsCString());
return persistent_fn;
llvm::toString(std::move(err)).c_str());
return nullptr;
}
persistent_fn = type_system->GetFunctionCaller(return_type, function_address,
arg_value_list, name);
auto *persistent_fn = type_system_or_err->GetFunctionCaller(
return_type, function_address, arg_value_list, name);
if (!persistent_fn)
error.SetErrorStringWithFormat(
"Could not create an expression for language %s",
@ -2226,20 +2219,17 @@ UtilityFunction *
Target::GetUtilityFunctionForLanguage(const char *text,
lldb::LanguageType language,
const char *name, Status &error) {
Status type_system_error;
TypeSystem *type_system =
GetScratchTypeSystemForLanguage(&type_system_error, language);
UtilityFunction *utility_fn = nullptr;
auto type_system_or_err = GetScratchTypeSystemForLanguage(language);
if (!type_system) {
if (auto err = type_system_or_err.takeError()) {
error.SetErrorStringWithFormat(
"Could not find type system for language %s: %s",
Language::GetNameForLanguageType(language),
type_system_error.AsCString());
return utility_fn;
llvm::toString(std::move(err)).c_str());
return nullptr;
}
utility_fn = type_system->GetUtilityFunction(text, name);
auto *utility_fn = type_system_or_err->GetUtilityFunction(text, name);
if (!utility_fn)
error.SetErrorStringWithFormat(
"Could not create an expression for language %s",
@ -2249,12 +2239,17 @@ Target::GetUtilityFunctionForLanguage(const char *text,
}
ClangASTContext *Target::GetScratchClangASTContext(bool create_on_demand) {
if (m_valid) {
if (TypeSystem *type_system = GetScratchTypeSystemForLanguage(
nullptr, eLanguageTypeC, create_on_demand))
return llvm::dyn_cast<ClangASTContext>(type_system);
if (!m_valid)
return nullptr;
auto type_system_or_err =
GetScratchTypeSystemForLanguage(eLanguageTypeC, create_on_demand);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),
std::move(err), "Couldn't get scratch ClangASTContext");
return nullptr;
}
return nullptr;
return llvm::dyn_cast<ClangASTContext>(&type_system_or_err.get());
}
ClangASTImporterSP Target::GetClangASTImporter() {
@ -2348,13 +2343,19 @@ ExpressionResults Target::EvaluateExpression(
// Make sure we aren't just trying to see the value of a persistent variable
// (something like "$0")
lldb::ExpressionVariableSP persistent_var_sp;
// Only check for persistent variables the expression starts with a '$'
if (expr[0] == '$')
persistent_var_sp = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC)
->GetPersistentExpressionState()
->GetVariable(expr);
lldb::ExpressionVariableSP persistent_var_sp;
if (expr[0] == '$') {
auto type_system_or_err =
GetScratchTypeSystemForLanguage(eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),
std::move(err), "Unable to get scratch type system");
} else {
persistent_var_sp =
type_system_or_err->GetPersistentExpressionState()->GetVariable(expr);
}
}
if (persistent_var_sp) {
result_valobj_sp = persistent_var_sp->GetValueObject();
execution_results = eExpressionCompleted;

19
lldb/source/Target/ThreadPlanTracer.cpp
View File

@ -93,15 +93,20 @@ Disassembler *ThreadPlanAssemblyTracer::GetDisassembler() {
TypeFromUser ThreadPlanAssemblyTracer::GetIntPointerType() {
if (!m_intptr_type.IsValid()) {
TargetSP target_sp(m_thread.CalculateTarget());
if (target_sp) {
TypeSystem *type_system =
target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
if (type_system)
m_intptr_type =
TypeFromUser(type_system->GetBuiltinTypeForEncodingAndBitSize(
if (auto target_sp = m_thread.CalculateTarget()) {
auto type_system_or_err =
target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TYPES),
std::move(err),
"Unable to get integer pointer type from TypeSystem");
} else {
m_intptr_type = TypeFromUser(
type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
eEncodingUint,
target_sp->GetArchitecture().GetAddressByteSize() * 8));
}
}
}
return m_intptr_type;

11
lldb/tools/lldb-test/lldb-test.cpp
View File

@ -528,10 +528,15 @@ Error opts::symbols::dumpAST(lldb_private::Module &Module) {
if (!symfile)
return make_string_error("Module has no symbol file.");
auto clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus));
auto type_system_or_err =
symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
if (!type_system_or_err)
return make_string_error("Can't retrieve ClangASTContext");
auto *clang_ast_ctx =
llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
if (!clang_ast_ctx)
return make_string_error("Can't retrieve Clang AST context.");
return make_string_error("Retrieved TypeSystem was not a ClangASTContext");
auto ast_ctx = clang_ast_ctx->getASTContext();
if (!ast_ctx)