// The type in the Clang module must have the same language as the current CU.
LanguageSet languages;
- languages.Insert(die.GetCU()->GetLanguageType());
+ languages.Insert(SymbolFileDWARF::GetLanguage(*die.GetCU()));
llvm::DenseSet<SymbolFile *> searched_symbol_files;
clang_module_sp->GetSymbolFile()->FindTypes(decl_context, languages,
searched_symbol_files, pcm_types);
DWARF_LOG_LOOKUPS));
SymbolFileDWARF *dwarf = die.GetDWARF();
const dw_tag_t tag = die.Tag();
- LanguageType cu_language = die.GetLanguage();
+ LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
Type::ResolveState resolve_state = Type::ResolveState::Unresolved;
Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
TypeSP type_sp;
if (type_sp)
return type_sp;
- DWARFDeclContext die_decl_ctx;
- die.GetDWARFDeclContext(die_decl_ctx);
+ DWARFDeclContext die_decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
CompilerType clang_type;
const dw_tag_t tag = die.Tag();
SymbolFileDWARF *dwarf = die.GetDWARF();
- LanguageType cu_language = die.GetLanguage();
+ LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_TYPE_COMPLETION |
DWARF_LOG_LOOKUPS);
if (type_sp)
return type_sp;
- DWARFDeclContext die_decl_ctx;
- die.GetDWARFDeclContext(die_decl_ctx);
+ DWARFDeclContext die_decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
// type_sp = FindDefinitionTypeForDIE (dwarf_cu, die,
// type_name_const_str);
func_name.SetValue(ConstString(mangled), true);
else if ((die.GetParent().Tag() == DW_TAG_compile_unit ||
die.GetParent().Tag() == DW_TAG_partial_unit) &&
- Language::LanguageIsCPlusPlus(die.GetLanguage()) &&
- !Language::LanguageIsObjC(die.GetLanguage()) && name &&
- strcmp(name, "main") != 0) {
+ Language::LanguageIsCPlusPlus(
+ SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
+ !Language::LanguageIsObjC(
+ SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
+ name && strcmp(name, "main") != 0) {
// If the mangled name is not present in the DWARF, generate the
// demangled name using the decl context. We skip if the function is
// "main" as its name is never mangled.
unsigned type_quals = 0;
std::vector<CompilerType> param_types;
std::vector<clang::ParmVarDecl *> param_decls;
- DWARFDeclContext decl_ctx;
StreamString sstr;
- die.GetDWARFDeclContext(decl_ctx);
+ DWARFDeclContext decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
sstr << decl_ctx.GetQualifiedName();
clang::DeclContext *containing_decl_ctx =
SymbolFileDWARF *dwarf = die.GetDWARF();
DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
if (imported_uid) {
- CompilerDecl imported_decl = imported_uid.GetDecl();
+ CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(imported_uid);
if (imported_decl) {
clang::DeclContext *decl_context =
TypeSystemClang::DeclContextGetAsDeclContext(
DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
if (imported_uid) {
- CompilerDeclContext imported_decl_ctx = imported_uid.GetDeclContext();
+ CompilerDeclContext imported_decl_ctx =
+ SymbolFileDWARF::GetDeclContext(imported_uid);
if (imported_decl_ctx) {
clang::DeclContext *decl_context =
TypeSystemClang::DeclContextGetAsDeclContext(
}
DWARFASTParserClang *src_dwarf_ast_parser =
- (DWARFASTParserClang *)src_die.GetDWARFParser();
+ (DWARFASTParserClang *)SymbolFileDWARF::GetDWARFParser(*src_die.GetCU());
DWARFASTParserClang *dst_dwarf_ast_parser =
- (DWARFASTParserClang *)dst_die.GetDWARFParser();
+ (DWARFASTParserClang *)SymbolFileDWARF::GetDWARFParser(*dst_die.GetCU());
// Now do the work of linking the DeclContexts and Types.
if (fast_path) {
return nullptr;
}
-lldb::LanguageType DWARFBaseDIE::GetLanguage() const {
- if (IsValid())
- return m_cu->GetLanguageType();
- else
- return lldb::eLanguageTypeUnknown;
-}
-
lldb::ModuleSP DWARFBaseDIE::GetModule() const {
SymbolFileDWARF *dwarf = GetDWARF();
if (dwarf)
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 {
- 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 {
return m_die && m_die->HasChildren();
}
llvm::Optional<DIERef> GetDIERef() const;
- llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem() const;
-
- DWARFASTParser *GetDWARFParser() const;
-
void Set(DWARFUnit *cu, DWARFDebugInfoEntry *die) {
if (cu && die) {
m_cu = cu;
const char *GetName() const;
- lldb::LanguageType GetLanguage() const;
-
lldb::ModuleSP GetModule() const;
// Getting attribute values from the DIE.
return result;
}
-void DWARFDIE::GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const {
- if (IsValid()) {
- dwarf_decl_ctx.SetLanguage(GetLanguage());
- m_die->GetDWARFDeclContext(GetCU(), dwarf_decl_ctx);
- } else {
- dwarf_decl_ctx.Clear();
- }
-}
-
void DWARFDIE::GetDeclContext(
llvm::SmallVectorImpl<lldb_private::CompilerContext> &context) const {
const dw_tag_t tag = Tag();
} else
return false;
}
-
-CompilerDecl DWARFDIE::GetDecl() const {
- DWARFASTParser *dwarf_ast = GetDWARFParser();
- if (dwarf_ast)
- return dwarf_ast->GetDeclForUIDFromDWARF(*this);
- else
- return CompilerDecl();
-}
-
-CompilerDeclContext DWARFDIE::GetDeclContext() const {
- DWARFASTParser *dwarf_ast = GetDWARFParser();
- if (dwarf_ast)
- return dwarf_ast->GetDeclContextForUIDFromDWARF(*this);
- else
- return CompilerDeclContext();
-}
-
-CompilerDeclContext DWARFDIE::GetContainingDeclContext() const {
- DWARFASTParser *dwarf_ast = GetDWARFParser();
- if (dwarf_ast)
- return dwarf_ast->GetDeclContextContainingUIDFromDWARF(*this);
- else
- return CompilerDeclContext();
-}
// DeclContext related functions
std::vector<DWARFDIE> GetDeclContextDIEs() const;
- void GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const;
-
/// Return this DIE's decl context as it is needed to look up types
/// in Clang's -gmodules debug info format.
void GetDeclContext(
int &decl_line, int &decl_column, int &call_file,
int &call_line, int &call_column,
lldb_private::DWARFExpression *frame_base) const;
-
- // CompilerDecl related functions
-
- lldb_private::CompilerDecl GetDecl() const;
-
- lldb_private::CompilerDeclContext GetDeclContext() const;
-
- lldb_private::CompilerDeclContext GetContainingDeclContext() const;
};
#endif // SymbolFileDWARF_DWARFDIE_h_
}
}
-void DWARFDebugInfoEntry::GetDWARFDeclContext(
- DWARFUnit *cu, DWARFDeclContext &dwarf_decl_ctx) const {
+DWARFDeclContext DWARFDebugInfoEntry::GetDWARFDeclContext(DWARFUnit *cu) const {
+ DWARFDeclContext dwarf_decl_ctx;
const dw_tag_t tag = Tag();
if (tag != DW_TAG_compile_unit && tag != DW_TAG_partial_unit) {
- dwarf_decl_ctx.AppendDeclContext(tag, GetName(cu));
DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(cu);
if (parent_decl_ctx_die && parent_decl_ctx_die.GetDIE() != this) {
if (parent_decl_ctx_die.Tag() != DW_TAG_compile_unit &&
parent_decl_ctx_die.Tag() != DW_TAG_partial_unit)
- parent_decl_ctx_die.GetDIE()->GetDWARFDeclContext(
- parent_decl_ctx_die.GetCU(), dwarf_decl_ctx);
+ dwarf_decl_ctx = parent_decl_ctx_die.GetDIE()->GetDWARFDeclContext(
+ parent_decl_ctx_die.GetCU());
}
+ dwarf_decl_ctx.AppendDeclContext(tag, GetName(cu));
}
+ return dwarf_decl_ctx;
}
DWARFDIE
return HasChildren() ? this + 1 : nullptr;
}
- void GetDWARFDeclContext(DWARFUnit *cu,
- DWARFDeclContext &dwarf_decl_ctx) const;
+ DWARFDeclContext GetDWARFDeclContext(DWARFUnit *cu) const;
DWARFDIE GetParentDeclContextDIE(DWARFUnit *cu) const;
DWARFDIE GetParentDeclContextDIE(DWARFUnit *cu,
return m_dwarf.GetObjectFile()->GetByteOrder();
}
-llvm::Expected<TypeSystem &> DWARFUnit::GetTypeSystem() {
- return m_dwarf.GetTypeSystemForLanguage(GetLanguageType());
-}
-
void DWARFUnit::SetBaseAddress(dw_addr_t base_addr) { m_base_addr = base_addr; }
// Compare function DWARFDebugAranges::Range structures
ParseProducerInfo();
return m_producer_version_update;
}
-LanguageType DWARFUnit::LanguageTypeFromDWARF(uint64_t val) {
- // Note: user languages between lo_user and hi_user must be handled
- // explicitly here.
- switch (val) {
- case DW_LANG_Mips_Assembler:
- return eLanguageTypeMipsAssembler;
- case DW_LANG_GOOGLE_RenderScript:
- return eLanguageTypeExtRenderScript;
- default:
- return static_cast<LanguageType>(val);
- }
-}
-LanguageType DWARFUnit::GetLanguageType() {
- if (m_language_type != eLanguageTypeUnknown)
- return m_language_type;
+uint64_t DWARFUnit::GetDWARFLanguageType() {
+ if (m_language_type)
+ return *m_language_type;
const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
- if (die)
- m_language_type = LanguageTypeFromDWARF(
- die->GetAttributeValueAsUnsigned(this, DW_AT_language, 0));
- return m_language_type;
+ if (!die)
+ m_language_type = 0;
+ else
+ m_language_type = die->GetAttributeValueAsUnsigned(this, DW_AT_language, 0);
+ return *m_language_type;
}
bool DWARFUnit::GetIsOptimized() {
lldb::ByteOrder GetByteOrder() const;
- llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem();
-
const DWARFDebugAranges &GetFunctionAranges();
void SetBaseAddress(dw_addr_t base_addr);
uint32_t GetProducerVersionUpdate();
- static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
-
- lldb::LanguageType GetLanguageType();
+ uint64_t GetDWARFLanguageType();
bool GetIsOptimized();
uint32_t m_producer_version_major = 0;
uint32_t m_producer_version_minor = 0;
uint32_t m_producer_version_update = 0;
- lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
+ llvm::Optional<uint64_t> m_language_type;
lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
llvm::Optional<lldb_private::FileSpec> m_comp_dir;
llvm::Optional<lldb_private::FileSpec> m_file_spec;
unit.GetOffset());
}
- const LanguageType cu_language = unit.GetLanguageType();
+ const LanguageType cu_language = SymbolFileDWARF::GetLanguage(unit);
IndexUnitImpl(unit, cu_language, set);
cu_file_spec.SetFile(remapped_file, FileSpec::Style::native);
}
- LanguageType cu_language = DWARFUnit::LanguageTypeFromDWARF(
+ LanguageType cu_language = SymbolFileDWARF::LanguageTypeFromDWARF(
cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
bool is_optimized = dwarf_cu.GetNonSkeletonUnit().GetIsOptimized();
if (!die.IsValid())
return nullptr;
- auto type_system_or_err =
- GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
+ auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to parse function");
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
if (dwarf_cu)
- return dwarf_cu->GetLanguageType();
+ return GetLanguage(*dwarf_cu);
else
return eLanguageTypeUnknown;
}
// SymbolFileDWARF::GetDIE(). See comments inside the
// SymbolFileDWARF::GetDIE() for details.
if (DWARFDIE die = GetDIE(type_uid))
- return die.GetDecl();
+ return GetDecl(die);
return CompilerDecl();
}
// SymbolFileDWARF::GetDIE(). See comments inside the
// SymbolFileDWARF::GetDIE() for details.
if (DWARFDIE die = GetDIE(type_uid))
- return die.GetDeclContext();
+ return GetDeclContext(die);
return CompilerDeclContext();
}
// SymbolFileDWARF::GetDIE(). See comments inside the
// SymbolFileDWARF::GetDIE() for details.
if (DWARFDIE die = GetDIE(type_uid))
- return die.GetContainingDeclContext();
+ return GetContainingDeclContext(die);
return CompilerDeclContext();
}
dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
type->GetName().AsCString());
assert(compiler_type);
- DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser();
- if (dwarf_ast)
+ if (DWARFASTParser *dwarf_ast = GetDWARFParser(*dwarf_die.GetCU()))
return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
}
return false;
sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
if (parent_decl_ctx) {
- DWARFASTParser *dwarf_ast = die.GetDWARFParser();
- if (dwarf_ast) {
+ if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
CompilerDeclContext actual_parent_decl_ctx =
dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
if (!actual_parent_decl_ctx ||
return true;
if (die) {
- DWARFASTParser *dwarf_ast = die.GetDWARFParser();
- if (dwarf_ast) {
- CompilerDeclContext actual_decl_ctx =
- dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
- if (actual_decl_ctx)
+ if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
+ if (CompilerDeclContext actual_decl_ctx =
+ dwarf_ast->GetDeclContextContainingUIDFromDWARF(die))
return decl_ctx->IsContainedInLookup(actual_decl_ctx);
}
}
m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
continue;
}
- if (!languages[die.GetCU()->GetLanguageType()])
+ if (!languages[GetLanguage(*die.GetCU())])
continue;
llvm::SmallVector<CompilerContext, 4> die_context;
if (!DIEInDeclContext(parent_decl_ctx, die))
continue; // The containing decl contexts don't match
- DWARFASTParser *dwarf_ast = die.GetDWARFParser();
- if (dwarf_ast) {
+ if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
if (namespace_decl_ctx)
break;
// looking for. We don't want to find a "Foo" type from Java if we
// are looking for a "Foo" type for C, C++, ObjC, or ObjC++.
if (type_system &&
- !type_system->SupportsLanguage(type_die.GetLanguage()))
+ !type_system->SupportsLanguage(GetLanguage(*type_die.GetCU())))
continue;
bool try_resolving_type = false;
}
if (try_resolving_type) {
- DWARFDeclContext type_dwarf_decl_ctx;
- type_die.GetDWARFDeclContext(type_dwarf_decl_ctx);
+ DWARFDeclContext type_dwarf_decl_ctx =
+ GetDWARFDeclContext(type_die);
if (log) {
GetObjectFile()->GetModule()->LogMessage(
if (!die)
return {};
- auto type_system_or_err =
- GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
+ auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
if (auto err = type_system_or_err.takeError()) {
LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
std::move(err), "Unable to parse type");
// declaration context.
if ((parent_tag == DW_TAG_compile_unit ||
parent_tag == DW_TAG_partial_unit) &&
- Language::LanguageIsCPlusPlus(die.GetLanguage())) {
- DWARFDeclContext decl_ctx;
-
- die.GetDWARFDeclContext(decl_ctx);
- mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString();
- }
+ Language::LanguageIsCPlusPlus(GetLanguage(*die.GetCU())))
+ mangled = GetDWARFDeclContext(die)
+ .GetQualifiedNameAsConstString()
+ .GetCString();
}
if (tag == DW_TAG_formal_parameter)
});
return m_dwp_symfile.get();
}
+
+llvm::Expected<TypeSystem &> SymbolFileDWARF::GetTypeSystem(DWARFUnit &unit) {
+ return unit.GetSymbolFileDWARF().GetTypeSystemForLanguage(GetLanguage(unit));
+}
+
+DWARFASTParser *SymbolFileDWARF::GetDWARFParser(DWARFUnit &unit) {
+ auto type_system_or_err = GetTypeSystem(unit);
+ 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();
+}
+
+CompilerDecl SymbolFileDWARF::GetDecl(const DWARFDIE &die) {
+ if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
+ return dwarf_ast->GetDeclForUIDFromDWARF(die);
+ return CompilerDecl();
+}
+
+CompilerDeclContext SymbolFileDWARF::GetDeclContext(const DWARFDIE &die) {
+ if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
+ return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
+ return CompilerDeclContext();
+}
+
+CompilerDeclContext
+SymbolFileDWARF::GetContainingDeclContext(const DWARFDIE &die) {
+ if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
+ return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
+ return CompilerDeclContext();
+}
+
+DWARFDeclContext SymbolFileDWARF::GetDWARFDeclContext(const DWARFDIE &die) {
+ if (!die.IsValid())
+ return {};
+ DWARFDeclContext dwarf_decl_ctx =
+ die.GetDIE()->GetDWARFDeclContext(die.GetCU());
+ dwarf_decl_ctx.SetLanguage(GetLanguage(*die.GetCU()));
+ return dwarf_decl_ctx;
+}
+
+LanguageType SymbolFileDWARF::LanguageTypeFromDWARF(uint64_t val) {
+ // Note: user languages between lo_user and hi_user must be handled
+ // explicitly here.
+ switch (val) {
+ case DW_LANG_Mips_Assembler:
+ return eLanguageTypeMipsAssembler;
+ case DW_LANG_GOOGLE_RenderScript:
+ return eLanguageTypeExtRenderScript;
+ default:
+ return static_cast<LanguageType>(val);
+ }
+}
+
+LanguageType SymbolFileDWARF::GetLanguage(DWARFUnit &unit) {
+ return LanguageTypeFromDWARF(unit.GetDWARFLanguageType());
+}
lldb_private::FileSpec GetFile(DWARFUnit &unit, size_t file_idx);
+ static llvm::Expected<lldb_private::TypeSystem &>
+ GetTypeSystem(DWARFUnit &unit);
+
+ static DWARFASTParser *GetDWARFParser(DWARFUnit &unit);
+
+ // CompilerDecl related functions
+
+ static lldb_private::CompilerDecl GetDecl(const DWARFDIE &die);
+
+ static lldb_private::CompilerDeclContext GetDeclContext(const DWARFDIE &die);
+
+ static lldb_private::CompilerDeclContext
+ GetContainingDeclContext(const DWARFDIE &die);
+
+ static DWARFDeclContext GetDWARFDeclContext(const DWARFDIE &die);
+
+ static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
+
+ static lldb::LanguageType GetLanguage(DWARFUnit &unit);
+
protected:
typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
DIEToTypePtr;
OSDN Git Service
