| //===-- DWARFASTParserClang.cpp -------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include <cstdlib> |
| |
| #include "DWARFASTParser.h" |
| #include "DWARFASTParserClang.h" |
| #include "DWARFDebugInfo.h" |
| #include "DWARFDeclContext.h" |
| #include "DWARFDefines.h" |
| #include "SymbolFileDWARF.h" |
| #include "SymbolFileDWARFDebugMap.h" |
| #include "SymbolFileDWARFDwo.h" |
| #include "UniqueDWARFASTType.h" |
| |
| #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h" |
| #include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h" |
| #include "Plugins/ExpressionParser/Clang/ClangUtil.h" |
| #include "Plugins/Language/ObjC/ObjCLanguage.h" |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/Value.h" |
| #include "lldb/Host/Host.h" |
| #include "lldb/Symbol/CompileUnit.h" |
| #include "lldb/Symbol/Function.h" |
| #include "lldb/Symbol/ObjectFile.h" |
| #include "lldb/Symbol/SymbolFile.h" |
| #include "lldb/Symbol/TypeList.h" |
| #include "lldb/Symbol/TypeMap.h" |
| #include "lldb/Symbol/VariableList.h" |
| #include "lldb/Target/Language.h" |
| #include "lldb/Utility/LLDBAssert.h" |
| #include "lldb/Utility/Log.h" |
| #include "lldb/Utility/StreamString.h" |
| |
| #include "clang/AST/CXXInheritance.h" |
| #include "clang/AST/DeclBase.h" |
| #include "clang/AST/DeclCXX.h" |
| #include "clang/AST/DeclObjC.h" |
| #include "clang/AST/DeclTemplate.h" |
| #include "clang/AST/Type.h" |
| #include "clang/Basic/Specifiers.h" |
| #include "llvm/ADT/StringExtras.h" |
| #include "llvm/DebugInfo/DWARF/DWARFAddressRange.h" |
| #include "llvm/DebugInfo/DWARF/DWARFTypePrinter.h" |
| #include "llvm/Demangle/Demangle.h" |
| |
| #include <map> |
| #include <memory> |
| #include <optional> |
| #include <vector> |
| |
| //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN |
| |
| #ifdef ENABLE_DEBUG_PRINTF |
| #include <cstdio> |
| #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__) |
| #else |
| #define DEBUG_PRINTF(fmt, ...) |
| #endif |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| using namespace lldb_private::dwarf; |
| using namespace lldb_private::plugin::dwarf; |
| |
| DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast) |
| : DWARFASTParser(Kind::DWARFASTParserClang), m_ast(ast), |
| m_die_to_decl_ctx(), m_decl_ctx_to_die() {} |
| |
| DWARFASTParserClang::~DWARFASTParserClang() = default; |
| |
| static bool DeclKindIsCXXClass(clang::Decl::Kind decl_kind) { |
| switch (decl_kind) { |
| case clang::Decl::CXXRecord: |
| case clang::Decl::ClassTemplateSpecialization: |
| return true; |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| |
| ClangASTImporter &DWARFASTParserClang::GetClangASTImporter() { |
| if (!m_clang_ast_importer_up) { |
| m_clang_ast_importer_up = std::make_unique<ClangASTImporter>(); |
| } |
| return *m_clang_ast_importer_up; |
| } |
| |
| /// Detect a forward declaration that is nested in a DW_TAG_module. |
| static bool IsClangModuleFwdDecl(const DWARFDIE &Die) { |
| if (!Die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0)) |
| return false; |
| auto Parent = Die.GetParent(); |
| while (Parent.IsValid()) { |
| if (Parent.Tag() == DW_TAG_module) |
| return true; |
| Parent = Parent.GetParent(); |
| } |
| return false; |
| } |
| |
| static DWARFDIE GetContainingClangModuleDIE(const DWARFDIE &die) { |
| if (die.IsValid()) { |
| DWARFDIE top_module_die; |
| // Now make sure this DIE is scoped in a DW_TAG_module tag and return true |
| // if so |
| for (DWARFDIE parent = die.GetParent(); parent.IsValid(); |
| parent = parent.GetParent()) { |
| const dw_tag_t tag = parent.Tag(); |
| if (tag == DW_TAG_module) |
| top_module_die = parent; |
| else if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit) |
| break; |
| } |
| |
| return top_module_die; |
| } |
| return DWARFDIE(); |
| } |
| |
| static lldb::ModuleSP GetContainingClangModule(const DWARFDIE &die) { |
| if (die.IsValid()) { |
| DWARFDIE clang_module_die = GetContainingClangModuleDIE(die); |
| |
| if (clang_module_die) { |
| const char *module_name = clang_module_die.GetName(); |
| if (module_name) |
| return die.GetDWARF()->GetExternalModule( |
| lldb_private::ConstString(module_name)); |
| } |
| } |
| return lldb::ModuleSP(); |
| } |
| |
| // Returns true if the given artificial field name should be ignored when |
| // parsing the DWARF. |
| static bool ShouldIgnoreArtificialField(llvm::StringRef FieldName) { |
| return FieldName.starts_with("_vptr$") |
| // gdb emit vtable pointer as "_vptr.classname" |
| || FieldName.starts_with("_vptr."); |
| } |
| |
| /// Returns true for C++ constructs represented by clang::CXXRecordDecl |
| static bool TagIsRecordType(dw_tag_t tag) { |
| switch (tag) { |
| case DW_TAG_class_type: |
| case DW_TAG_structure_type: |
| case DW_TAG_union_type: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /// Get the object parameter DIE if one exists, otherwise returns |
| /// a default DWARFDIE. If \c containing_decl_ctx is not a valid |
| /// C++ declaration context for class methods, assume no object |
| /// parameter exists for the given \c subprogram. |
| static DWARFDIE |
| GetCXXObjectParameter(const DWARFDIE &subprogram, |
| const clang::DeclContext &containing_decl_ctx) { |
| assert(subprogram.Tag() == DW_TAG_subprogram || |
| subprogram.Tag() == DW_TAG_inlined_subroutine || |
| subprogram.Tag() == DW_TAG_subroutine_type); |
| |
| if (!DeclKindIsCXXClass(containing_decl_ctx.getDeclKind())) |
| return {}; |
| |
| if (DWARFDIE object_parameter = |
| subprogram.GetAttributeValueAsReferenceDIE(DW_AT_object_pointer)) |
| return object_parameter; |
| |
| // If no DW_AT_object_pointer was specified, assume the implicit object |
| // parameter is the first parameter to the function, is called "this" and is |
| // artificial (which is what most compilers would generate). |
| auto children = subprogram.children(); |
| auto it = llvm::find_if(children, [](const DWARFDIE &child) { |
| return child.Tag() == DW_TAG_formal_parameter; |
| }); |
| |
| if (it == children.end()) |
| return {}; |
| |
| DWARFDIE object_pointer = *it; |
| |
| if (!object_pointer.GetAttributeValueAsUnsigned(DW_AT_artificial, 0)) |
| return {}; |
| |
| // Often times compilers omit the "this" name for the |
| // specification DIEs, so we can't rely upon the name being in |
| // the formal parameter DIE... |
| if (const char *name = object_pointer.GetName(); |
| name && ::strcmp(name, "this") != 0) |
| return {}; |
| |
| return object_pointer; |
| } |
| |
| /// In order to determine the CV-qualifiers for a C++ class |
| /// method in DWARF, we have to look at the CV-qualifiers of |
| /// the object parameter's type. |
| static unsigned GetCXXMethodCVQuals(const DWARFDIE &subprogram, |
| const DWARFDIE &object_parameter) { |
| if (!subprogram || !object_parameter) |
| return 0; |
| |
| Type *this_type = subprogram.ResolveTypeUID( |
| object_parameter.GetAttributeValueAsReferenceDIE(DW_AT_type)); |
| if (!this_type) |
| return 0; |
| |
| uint32_t encoding_mask = this_type->GetEncodingMask(); |
| unsigned cv_quals = 0; |
| if (encoding_mask & (1u << Type::eEncodingIsConstUID)) |
| cv_quals |= clang::Qualifiers::Const; |
| if (encoding_mask & (1u << Type::eEncodingIsVolatileUID)) |
| cv_quals |= clang::Qualifiers::Volatile; |
| |
| return cv_quals; |
| } |
| |
| TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc, |
| const DWARFDIE &die, |
| Log *log) { |
| ModuleSP clang_module_sp = GetContainingClangModule(die); |
| if (!clang_module_sp) |
| return TypeSP(); |
| |
| // If this type comes from a Clang module, recursively look in the |
| // DWARF section of the .pcm file in the module cache. Clang |
| // generates DWO skeleton units as breadcrumbs to find them. |
| std::vector<lldb_private::CompilerContext> die_context = die.GetDeclContext(); |
| TypeQuery query(die_context, TypeQueryOptions::e_module_search | |
| TypeQueryOptions::e_find_one); |
| TypeResults results; |
| |
| // The type in the Clang module must have the same language as the current CU. |
| query.AddLanguage(SymbolFileDWARF::GetLanguageFamily(*die.GetCU())); |
| clang_module_sp->FindTypes(query, results); |
| TypeSP pcm_type_sp = results.GetTypeMap().FirstType(); |
| if (!pcm_type_sp) { |
| // Since this type is defined in one of the Clang modules imported |
| // by this symbol file, search all of them. Instead of calling |
| // sym_file->FindTypes(), which would return this again, go straight |
| // to the imported modules. |
| auto &sym_file = die.GetCU()->GetSymbolFileDWARF(); |
| |
| // Well-formed clang modules never form cycles; guard against corrupted |
| // ones by inserting the current file. |
| results.AlreadySearched(&sym_file); |
| sym_file.ForEachExternalModule( |
| *sc.comp_unit, results.GetSearchedSymbolFiles(), [&](Module &module) { |
| module.FindTypes(query, results); |
| pcm_type_sp = results.GetTypeMap().FirstType(); |
| return (bool)pcm_type_sp; |
| }); |
| } |
| |
| if (!pcm_type_sp) |
| return TypeSP(); |
| |
| // We found a real definition for this type in the Clang module, so lets use |
| // it and cache the fact that we found a complete type for this die. |
| lldb_private::CompilerType pcm_type = pcm_type_sp->GetForwardCompilerType(); |
| lldb_private::CompilerType type = |
| GetClangASTImporter().CopyType(m_ast, pcm_type); |
| |
| if (!type) |
| return TypeSP(); |
| |
| // Under normal operation pcm_type is a shallow forward declaration |
| // that gets completed later. This is necessary to support cyclic |
| // data structures. If, however, pcm_type is already complete (for |
| // example, because it was loaded for a different target before), |
| // the definition needs to be imported right away, too. |
| // Type::ResolveClangType() effectively ignores the ResolveState |
| // inside type_sp and only looks at IsDefined(), so it never calls |
| // ClangASTImporter::ASTImporterDelegate::ImportDefinitionTo(), |
| // which does extra work for Objective-C classes. This would result |
| // in only the forward declaration to be visible. |
| if (pcm_type.IsDefined()) |
| GetClangASTImporter().RequireCompleteType(ClangUtil::GetQualType(type)); |
| |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| auto type_sp = dwarf->MakeType( |
| die.GetID(), pcm_type_sp->GetName(), |
| llvm::expectedToOptional(pcm_type_sp->GetByteSize(nullptr)), nullptr, |
| LLDB_INVALID_UID, Type::eEncodingInvalid, &pcm_type_sp->GetDeclaration(), |
| type, Type::ResolveState::Forward, |
| TypePayloadClang(GetOwningClangModule(die))); |
| clang::TagDecl *tag_decl = TypeSystemClang::GetAsTagDecl(type); |
| if (tag_decl) { |
| LinkDeclContextToDIE(tag_decl, die); |
| } else { |
| clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die); |
| if (defn_decl_ctx) |
| LinkDeclContextToDIE(defn_decl_ctx, die); |
| } |
| |
| return type_sp; |
| } |
| |
| /// This function ensures we are able to add members (nested types, functions, |
| /// etc.) to this type. It does so by starting its definition even if one cannot |
| /// be found in the debug info. This means the type may need to be "forcibly |
| /// completed" later -- see CompleteTypeFromDWARF). |
| static void PrepareContextToReceiveMembers(TypeSystemClang &ast, |
| ClangASTImporter &ast_importer, |
| clang::DeclContext *decl_ctx, |
| DWARFDIE die, |
| const char *type_name_cstr) { |
| auto *tag_decl_ctx = clang::dyn_cast<clang::TagDecl>(decl_ctx); |
| if (!tag_decl_ctx) |
| return; // Non-tag context are always ready. |
| |
| // We have already completed the type or it is already prepared. |
| if (tag_decl_ctx->isCompleteDefinition() || tag_decl_ctx->isBeingDefined()) |
| return; |
| |
| // If this tag was imported from another AST context (in the gmodules case), |
| // we can complete the type by doing a full import. |
| |
| // If this type was not imported from an external AST, there's nothing to do. |
| CompilerType type = ast.GetTypeForDecl(tag_decl_ctx); |
| if (type && ast_importer.CanImport(type)) { |
| auto qual_type = ClangUtil::GetQualType(type); |
| if (ast_importer.RequireCompleteType(qual_type)) |
| return; |
| die.GetDWARF()->GetObjectFile()->GetModule()->ReportError( |
| "Unable to complete the Decl context for DIE {0} at offset " |
| "{1:x16}.\nPlease file a bug report.", |
| type_name_cstr ? type_name_cstr : "", die.GetOffset()); |
| } |
| |
| // We don't have a type definition and/or the import failed, but we need to |
| // add members to it. Start the definition to make that possible. If the type |
| // has no external storage we also have to complete the definition. Otherwise, |
| // that will happen when we are asked to complete the type |
| // (CompleteTypeFromDWARF). |
| ast.StartTagDeclarationDefinition(type); |
| if (!tag_decl_ctx->hasExternalLexicalStorage()) { |
| ast.SetDeclIsForcefullyCompleted(tag_decl_ctx); |
| ast.CompleteTagDeclarationDefinition(type); |
| } |
| } |
| |
| ParsedDWARFTypeAttributes::ParsedDWARFTypeAttributes(const DWARFDIE &die) { |
| DWARFAttributes attributes = die.GetAttributes(); |
| for (size_t i = 0; i < attributes.Size(); ++i) { |
| dw_attr_t attr = attributes.AttributeAtIndex(i); |
| DWARFFormValue form_value; |
| if (!attributes.ExtractFormValueAtIndex(i, form_value)) |
| continue; |
| switch (attr) { |
| default: |
| break; |
| case DW_AT_abstract_origin: |
| abstract_origin = form_value; |
| break; |
| |
| case DW_AT_accessibility: |
| accessibility = |
| DWARFASTParser::GetAccessTypeFromDWARF(form_value.Unsigned()); |
| break; |
| |
| case DW_AT_artificial: |
| is_artificial = form_value.Boolean(); |
| break; |
| |
| case DW_AT_bit_stride: |
| bit_stride = form_value.Unsigned(); |
| break; |
| |
| case DW_AT_byte_size: |
| byte_size = form_value.Unsigned(); |
| break; |
| |
| case DW_AT_alignment: |
| alignment = form_value.Unsigned(); |
| break; |
| |
| case DW_AT_byte_stride: |
| byte_stride = form_value.Unsigned(); |
| break; |
| |
| case DW_AT_calling_convention: |
| calling_convention = form_value.Unsigned(); |
| break; |
| |
| case DW_AT_containing_type: |
| containing_type = form_value; |
| break; |
| |
| case DW_AT_decl_file: |
| // die.GetCU() can differ if DW_AT_specification uses DW_FORM_ref_addr. |
| decl.SetFile( |
| attributes.CompileUnitAtIndex(i)->GetFile(form_value.Unsigned())); |
| break; |
| case DW_AT_decl_line: |
| decl.SetLine(form_value.Unsigned()); |
| break; |
| case DW_AT_decl_column: |
| decl.SetColumn(form_value.Unsigned()); |
| break; |
| |
| case DW_AT_declaration: |
| is_forward_declaration = form_value.Boolean(); |
| break; |
| |
| case DW_AT_encoding: |
| encoding = form_value.Unsigned(); |
| break; |
| |
| case DW_AT_enum_class: |
| is_scoped_enum = form_value.Boolean(); |
| break; |
| |
| case DW_AT_explicit: |
| is_explicit = form_value.Boolean(); |
| break; |
| |
| case DW_AT_external: |
| if (form_value.Unsigned()) |
| storage = clang::SC_Extern; |
| break; |
| |
| case DW_AT_inline: |
| is_inline = form_value.Boolean(); |
| break; |
| |
| case DW_AT_linkage_name: |
| case DW_AT_MIPS_linkage_name: |
| mangled_name = form_value.AsCString(); |
| break; |
| |
| case DW_AT_name: |
| name.SetCString(form_value.AsCString()); |
| break; |
| |
| case DW_AT_object_pointer: |
| // GetAttributes follows DW_AT_specification. |
| // DW_TAG_subprogram definitions and declarations may both |
| // have a DW_AT_object_pointer. Don't overwrite the one |
| // we parsed for the definition with the one from the declaration. |
| if (!object_pointer.IsValid()) |
| object_pointer = form_value.Reference(); |
| break; |
| |
| case DW_AT_signature: |
| signature = form_value; |
| break; |
| |
| case DW_AT_specification: |
| specification = form_value; |
| break; |
| |
| case DW_AT_type: |
| type = form_value; |
| break; |
| |
| case DW_AT_virtuality: |
| is_virtual = form_value.Boolean(); |
| break; |
| |
| case DW_AT_APPLE_objc_complete_type: |
| is_complete_objc_class = form_value.Signed(); |
| break; |
| |
| case DW_AT_APPLE_objc_direct: |
| is_objc_direct_call = true; |
| break; |
| |
| case DW_AT_APPLE_runtime_class: |
| class_language = (LanguageType)form_value.Signed(); |
| break; |
| |
| case DW_AT_GNU_vector: |
| is_vector = form_value.Boolean(); |
| break; |
| case DW_AT_export_symbols: |
| exports_symbols = form_value.Boolean(); |
| break; |
| case DW_AT_rvalue_reference: |
| ref_qual = clang::RQ_RValue; |
| break; |
| case DW_AT_reference: |
| ref_qual = clang::RQ_LValue; |
| break; |
| case DW_AT_APPLE_enum_kind: |
| enum_kind = static_cast<clang::EnumExtensibilityAttr::Kind>( |
| form_value.Unsigned()); |
| break; |
| } |
| } |
| } |
| |
| static std::string GetUnitName(const DWARFDIE &die) { |
| if (DWARFUnit *unit = die.GetCU()) |
| return unit->GetAbsolutePath().GetPath(); |
| return "<missing DWARF unit path>"; |
| } |
| |
| TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc, |
| const DWARFDIE &die, |
| bool *type_is_new_ptr) { |
| if (type_is_new_ptr) |
| *type_is_new_ptr = false; |
| |
| if (!die) |
| return nullptr; |
| |
| Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups); |
| |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| if (log) { |
| DWARFDIE context_die; |
| clang::DeclContext *context = |
| GetClangDeclContextContainingDIE(die, &context_die); |
| |
| dwarf->GetObjectFile()->GetModule()->LogMessage( |
| log, |
| "DWARFASTParserClang::ParseTypeFromDWARF " |
| "(die = {0:x16}, decl_ctx = {1:p} (die " |
| "{2:x16})) {3} ({4}) name = '{5}')", |
| die.GetOffset(), static_cast<void *>(context), context_die.GetOffset(), |
| DW_TAG_value_to_name(die.Tag()), die.Tag(), die.GetName()); |
| } |
| |
| // Set a bit that lets us know that we are currently parsing this |
| if (auto [it, inserted] = |
| dwarf->GetDIEToType().try_emplace(die.GetDIE(), DIE_IS_BEING_PARSED); |
| !inserted) { |
| if (it->getSecond() == nullptr || it->getSecond() == DIE_IS_BEING_PARSED) |
| return nullptr; |
| return it->getSecond()->shared_from_this(); |
| } |
| |
| ParsedDWARFTypeAttributes attrs(die); |
| |
| TypeSP type_sp; |
| if (DWARFDIE signature_die = attrs.signature.Reference()) { |
| type_sp = ParseTypeFromDWARF(sc, signature_die, type_is_new_ptr); |
| if (type_sp) { |
| if (clang::DeclContext *decl_ctx = |
| GetCachedClangDeclContextForDIE(signature_die)) |
| LinkDeclContextToDIE(decl_ctx, die); |
| } |
| } else { |
| if (type_is_new_ptr) |
| *type_is_new_ptr = true; |
| |
| const dw_tag_t tag = die.Tag(); |
| |
| switch (tag) { |
| case DW_TAG_typedef: |
| case DW_TAG_base_type: |
| case DW_TAG_pointer_type: |
| case DW_TAG_reference_type: |
| case DW_TAG_rvalue_reference_type: |
| case DW_TAG_const_type: |
| case DW_TAG_restrict_type: |
| case DW_TAG_volatile_type: |
| case DW_TAG_LLVM_ptrauth_type: |
| case DW_TAG_atomic_type: |
| case DW_TAG_unspecified_type: |
| type_sp = ParseTypeModifier(sc, die, attrs); |
| break; |
| case DW_TAG_structure_type: |
| case DW_TAG_union_type: |
| case DW_TAG_class_type: |
| type_sp = ParseStructureLikeDIE(sc, die, attrs); |
| break; |
| case DW_TAG_enumeration_type: |
| type_sp = ParseEnum(sc, die, attrs); |
| break; |
| case DW_TAG_inlined_subroutine: |
| case DW_TAG_subprogram: |
| case DW_TAG_subroutine_type: |
| type_sp = ParseSubroutine(die, attrs); |
| break; |
| case DW_TAG_array_type: |
| type_sp = ParseArrayType(die, attrs); |
| break; |
| case DW_TAG_ptr_to_member_type: |
| type_sp = ParsePointerToMemberType(die, attrs); |
| break; |
| default: |
| dwarf->GetObjectFile()->GetModule()->ReportError( |
| "[{0:x16}]: unhandled type tag {1:x4} ({2}), " |
| "please file a bug and " |
| "attach the file at the start of this error message", |
| die.GetOffset(), tag, DW_TAG_value_to_name(tag)); |
| break; |
| } |
| UpdateSymbolContextScopeForType(sc, die, type_sp); |
| } |
| if (type_sp) { |
| dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get(); |
| } |
| return type_sp; |
| } |
| |
| static std::optional<uint32_t> |
| ExtractDataMemberLocation(DWARFDIE const &die, DWARFFormValue const &form_value, |
| ModuleSP module_sp) { |
| Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups); |
| |
| // With DWARF 3 and later, if the value is an integer constant, |
| // this form value is the offset in bytes from the beginning of |
| // the containing entity. |
| if (!form_value.BlockData()) |
| return form_value.Unsigned(); |
| |
| Value initialValue(0); |
| const DWARFDataExtractor &debug_info_data = die.GetData(); |
| uint32_t block_length = form_value.Unsigned(); |
| uint32_t block_offset = |
| form_value.BlockData() - debug_info_data.GetDataStart(); |
| |
| llvm::Expected<Value> memberOffset = DWARFExpression::Evaluate( |
| /*ExecutionContext=*/nullptr, |
| /*RegisterContext=*/nullptr, module_sp, |
| DataExtractor(debug_info_data, block_offset, block_length), die.GetCU(), |
| eRegisterKindDWARF, &initialValue, nullptr); |
| if (!memberOffset) { |
| LLDB_LOG_ERROR(log, memberOffset.takeError(), |
| "ExtractDataMemberLocation failed: {0}"); |
| return {}; |
| } |
| |
| return memberOffset->ResolveValue(nullptr).UInt(); |
| } |
| |
| static TypePayloadClang GetPtrAuthMofidierPayload(const DWARFDIE &die) { |
| auto getAttr = [&](llvm::dwarf::Attribute Attr, unsigned defaultValue = 0) { |
| return die.GetAttributeValueAsUnsigned(Attr, defaultValue); |
| }; |
| const unsigned key = getAttr(DW_AT_LLVM_ptrauth_key); |
| const bool addr_disc = getAttr(DW_AT_LLVM_ptrauth_address_discriminated); |
| const unsigned extra = getAttr(DW_AT_LLVM_ptrauth_extra_discriminator); |
| const bool isapointer = getAttr(DW_AT_LLVM_ptrauth_isa_pointer); |
| const bool authenticates_null_values = |
| getAttr(DW_AT_LLVM_ptrauth_authenticates_null_values); |
| const unsigned authentication_mode_int = getAttr( |
| DW_AT_LLVM_ptrauth_authentication_mode, |
| static_cast<unsigned>(clang::PointerAuthenticationMode::SignAndAuth)); |
| clang::PointerAuthenticationMode authentication_mode = |
| clang::PointerAuthenticationMode::SignAndAuth; |
| if (authentication_mode_int >= |
| static_cast<unsigned>(clang::PointerAuthenticationMode::None) && |
| authentication_mode_int <= |
| static_cast<unsigned>( |
| clang::PointerAuthenticationMode::SignAndAuth)) { |
| authentication_mode = |
| static_cast<clang::PointerAuthenticationMode>(authentication_mode_int); |
| } else { |
| die.GetDWARF()->GetObjectFile()->GetModule()->ReportError( |
| "[{0:x16}]: invalid pointer authentication mode method {1:x4}", |
| die.GetOffset(), authentication_mode_int); |
| } |
| auto ptr_auth = clang::PointerAuthQualifier::Create( |
| key, addr_disc, extra, authentication_mode, isapointer, |
| authenticates_null_values); |
| return TypePayloadClang(ptr_auth.getAsOpaqueValue()); |
| } |
| |
| lldb::TypeSP |
| DWARFASTParserClang::ParseTypeModifier(const SymbolContext &sc, |
| const DWARFDIE &die, |
| ParsedDWARFTypeAttributes &attrs) { |
| Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups); |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| const dw_tag_t tag = die.Tag(); |
| LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU()); |
| Type::ResolveState resolve_state = Type::ResolveState::Unresolved; |
| Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID; |
| TypePayloadClang payload(GetOwningClangModule(die)); |
| TypeSP type_sp; |
| CompilerType clang_type; |
| |
| if (tag == DW_TAG_typedef) { |
| // DeclContext will be populated when the clang type is materialized in |
| // Type::ResolveCompilerType. |
| PrepareContextToReceiveMembers( |
| m_ast, GetClangASTImporter(), |
| GetClangDeclContextContainingDIE(die, nullptr), die, |
| attrs.name.GetCString()); |
| |
| if (attrs.type.IsValid()) { |
| // Try to parse a typedef from the (DWARF embedded in the) Clang |
| // module file first as modules can contain typedef'ed |
| // structures that have no names like: |
| // |
| // typedef struct { int a; } Foo; |
| // |
| // In this case we will have a structure with no name and a |
| // typedef named "Foo" that points to this unnamed |
| // structure. The name in the typedef is the only identifier for |
| // the struct, so always try to get typedefs from Clang modules |
| // if possible. |
| // |
| // The type_sp returned will be empty if the typedef doesn't |
| // exist in a module file, so it is cheap to call this function |
| // just to check. |
| // |
| // If we don't do this we end up creating a TypeSP that says |
| // this is a typedef to type 0x123 (the DW_AT_type value would |
| // be 0x123 in the DW_TAG_typedef), and this is the unnamed |
| // structure type. We will have a hard time tracking down an |
| // unnammed structure type in the module debug info, so we make |
| // sure we don't get into this situation by always resolving |
| // typedefs from the module. |
| const DWARFDIE encoding_die = attrs.type.Reference(); |
| |
| // First make sure that the die that this is typedef'ed to _is_ |
| // just a declaration (DW_AT_declaration == 1), not a full |
| // definition since template types can't be represented in |
| // modules since only concrete instances of templates are ever |
| // emitted and modules won't contain those |
| if (encoding_die && |
| encoding_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 1) { |
| type_sp = ParseTypeFromClangModule(sc, die, log); |
| if (type_sp) |
| return type_sp; |
| } |
| } |
| } |
| |
| DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\") type => 0x%8.8lx\n", die.GetID(), |
| DW_TAG_value_to_name(tag), type_name_cstr, |
| encoding_uid.Reference()); |
| |
| switch (tag) { |
| default: |
| break; |
| |
| case DW_TAG_unspecified_type: |
| if (attrs.name == "nullptr_t" || attrs.name == "decltype(nullptr)") { |
| resolve_state = Type::ResolveState::Full; |
| clang_type = m_ast.GetBasicType(eBasicTypeNullPtr); |
| break; |
| } |
| // Fall through to base type below in case we can handle the type |
| // there... |
| [[fallthrough]]; |
| |
| case DW_TAG_base_type: |
| resolve_state = Type::ResolveState::Full; |
| clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize( |
| attrs.name.GetStringRef(), attrs.encoding, |
| attrs.byte_size.value_or(0) * 8); |
| break; |
| |
| case DW_TAG_pointer_type: |
| encoding_data_type = Type::eEncodingIsPointerUID; |
| break; |
| case DW_TAG_reference_type: |
| encoding_data_type = Type::eEncodingIsLValueReferenceUID; |
| break; |
| case DW_TAG_rvalue_reference_type: |
| encoding_data_type = Type::eEncodingIsRValueReferenceUID; |
| break; |
| case DW_TAG_typedef: |
| encoding_data_type = Type::eEncodingIsTypedefUID; |
| break; |
| case DW_TAG_const_type: |
| encoding_data_type = Type::eEncodingIsConstUID; |
| break; |
| case DW_TAG_restrict_type: |
| encoding_data_type = Type::eEncodingIsRestrictUID; |
| break; |
| case DW_TAG_volatile_type: |
| encoding_data_type = Type::eEncodingIsVolatileUID; |
| break; |
| case DW_TAG_LLVM_ptrauth_type: |
| encoding_data_type = Type::eEncodingIsLLVMPtrAuthUID; |
| payload = GetPtrAuthMofidierPayload(die); |
| break; |
| case DW_TAG_atomic_type: |
| encoding_data_type = Type::eEncodingIsAtomicUID; |
| break; |
| } |
| |
| if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID || |
| encoding_data_type == Type::eEncodingIsTypedefUID)) { |
| if (tag == DW_TAG_pointer_type) { |
| DWARFDIE target_die = die.GetReferencedDIE(DW_AT_type); |
| |
| if (target_die.GetAttributeValueAsUnsigned(DW_AT_APPLE_block, 0)) { |
| // Blocks have a __FuncPtr inside them which is a pointer to a |
| // function of the proper type. |
| |
| for (DWARFDIE child_die : target_die.children()) { |
| if (!strcmp(child_die.GetAttributeValueAsString(DW_AT_name, ""), |
| "__FuncPtr")) { |
| DWARFDIE function_pointer_type = |
| child_die.GetReferencedDIE(DW_AT_type); |
| |
| if (function_pointer_type) { |
| DWARFDIE function_type = |
| function_pointer_type.GetReferencedDIE(DW_AT_type); |
| |
| bool function_type_is_new_pointer; |
| TypeSP lldb_function_type_sp = ParseTypeFromDWARF( |
| sc, function_type, &function_type_is_new_pointer); |
| |
| if (lldb_function_type_sp) { |
| clang_type = m_ast.CreateBlockPointerType( |
| lldb_function_type_sp->GetForwardCompilerType()); |
| encoding_data_type = Type::eEncodingIsUID; |
| attrs.type.Clear(); |
| resolve_state = Type::ResolveState::Full; |
| } |
| } |
| |
| break; |
| } |
| } |
| } |
| } |
| |
| if (cu_language == eLanguageTypeObjC || |
| cu_language == eLanguageTypeObjC_plus_plus) { |
| if (attrs.name) { |
| if (attrs.name == "id") { |
| if (log) |
| dwarf->GetObjectFile()->GetModule()->LogMessage( |
| log, |
| "SymbolFileDWARF::ParseType (die = {0:x16}) {1} ({2}) '{3}' " |
| "is Objective-C 'id' built-in type.", |
| die.GetOffset(), DW_TAG_value_to_name(die.Tag()), die.Tag(), |
| die.GetName()); |
| clang_type = m_ast.GetBasicType(eBasicTypeObjCID); |
| encoding_data_type = Type::eEncodingIsUID; |
| attrs.type.Clear(); |
| resolve_state = Type::ResolveState::Full; |
| } else if (attrs.name == "Class") { |
| if (log) |
| dwarf->GetObjectFile()->GetModule()->LogMessage( |
| log, |
| "SymbolFileDWARF::ParseType (die = {0:x16}) {1} ({2}) '{3}' " |
| "is Objective-C 'Class' built-in type.", |
| die.GetOffset(), DW_TAG_value_to_name(die.Tag()), die.Tag(), |
| die.GetName()); |
| clang_type = m_ast.GetBasicType(eBasicTypeObjCClass); |
| encoding_data_type = Type::eEncodingIsUID; |
| attrs.type.Clear(); |
| resolve_state = Type::ResolveState::Full; |
| } else if (attrs.name == "SEL") { |
| if (log) |
| dwarf->GetObjectFile()->GetModule()->LogMessage( |
| log, |
| "SymbolFileDWARF::ParseType (die = {0:x16}) {1} ({2}) '{3}' " |
| "is Objective-C 'selector' built-in type.", |
| die.GetOffset(), DW_TAG_value_to_name(die.Tag()), die.Tag(), |
| die.GetName()); |
| clang_type = m_ast.GetBasicType(eBasicTypeObjCSel); |
| encoding_data_type = Type::eEncodingIsUID; |
| attrs.type.Clear(); |
| resolve_state = Type::ResolveState::Full; |
| } |
| } else if (encoding_data_type == Type::eEncodingIsPointerUID && |
| attrs.type.IsValid()) { |
| // Clang sometimes erroneously emits id as objc_object*. In that |
| // case we fix up the type to "id". |
| |
| const DWARFDIE encoding_die = attrs.type.Reference(); |
| |
| if (encoding_die && encoding_die.Tag() == DW_TAG_structure_type) { |
| llvm::StringRef struct_name = encoding_die.GetName(); |
| if (struct_name == "objc_object") { |
| if (log) |
| dwarf->GetObjectFile()->GetModule()->LogMessage( |
| log, |
| "SymbolFileDWARF::ParseType (die = {0:x16}) {1} ({2}) '{3}' " |
| "is 'objc_object*', which we overrode to 'id'.", |
| die.GetOffset(), DW_TAG_value_to_name(die.Tag()), die.Tag(), |
| die.GetName()); |
| clang_type = m_ast.GetBasicType(eBasicTypeObjCID); |
| encoding_data_type = Type::eEncodingIsUID; |
| attrs.type.Clear(); |
| resolve_state = Type::ResolveState::Full; |
| } |
| } |
| } |
| } |
| } |
| |
| return dwarf->MakeType(die.GetID(), attrs.name, attrs.byte_size, nullptr, |
| attrs.type.Reference().GetID(), encoding_data_type, |
| &attrs.decl, clang_type, resolve_state, payload); |
| } |
| |
| std::string DWARFASTParserClang::GetDIEClassTemplateParams(DWARFDIE die) { |
| if (DWARFDIE signature_die = die.GetReferencedDIE(DW_AT_signature)) |
| die = signature_die; |
| |
| if (llvm::StringRef(die.GetName()).contains("<")) |
| return {}; |
| |
| std::string name; |
| llvm::raw_string_ostream os(name); |
| llvm::DWARFTypePrinter<DWARFDIE> type_printer(os); |
| type_printer.appendAndTerminateTemplateParameters(die); |
| return name; |
| } |
| |
| void DWARFASTParserClang::MapDeclDIEToDefDIE( |
| const lldb_private::plugin::dwarf::DWARFDIE &decl_die, |
| const lldb_private::plugin::dwarf::DWARFDIE &def_die) { |
| LinkDeclContextToDIE(GetCachedClangDeclContextForDIE(decl_die), def_die); |
| SymbolFileDWARF *dwarf = def_die.GetDWARF(); |
| ParsedDWARFTypeAttributes decl_attrs(decl_die); |
| ParsedDWARFTypeAttributes def_attrs(def_die); |
| ConstString unique_typename(decl_attrs.name); |
| Declaration decl_declaration(decl_attrs.decl); |
| GetUniqueTypeNameAndDeclaration( |
| decl_die, SymbolFileDWARF::GetLanguage(*decl_die.GetCU()), |
| unique_typename, decl_declaration); |
| if (UniqueDWARFASTType *unique_ast_entry_type = |
| dwarf->GetUniqueDWARFASTTypeMap().Find( |
| unique_typename, decl_die, decl_declaration, |
| decl_attrs.byte_size.value_or(0), |
| decl_attrs.is_forward_declaration)) { |
| unique_ast_entry_type->UpdateToDefDIE(def_die, def_attrs.decl, |
| def_attrs.byte_size.value_or(0)); |
| } else if (Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups)) { |
| const dw_tag_t tag = decl_die.Tag(); |
| LLDB_LOG(log, |
| "Failed to find {0:x16} {1} ({2}) type \"{3}\" in " |
| "UniqueDWARFASTTypeMap", |
| decl_die.GetID(), DW_TAG_value_to_name(tag), tag, unique_typename); |
| } |
| } |
| |
| TypeSP DWARFASTParserClang::ParseEnum(const SymbolContext &sc, |
| const DWARFDIE &decl_die, |
| ParsedDWARFTypeAttributes &attrs) { |
| Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups); |
| SymbolFileDWARF *dwarf = decl_die.GetDWARF(); |
| const dw_tag_t tag = decl_die.Tag(); |
| |
| DWARFDIE def_die; |
| if (attrs.is_forward_declaration) { |
| if (TypeSP type_sp = ParseTypeFromClangModule(sc, decl_die, log)) |
| return type_sp; |
| |
| def_die = dwarf->FindDefinitionDIE(decl_die); |
| |
| if (!def_die) { |
| SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile(); |
| if (debug_map_symfile) { |
| // We weren't able to find a full declaration in this DWARF, |
| // see if we have a declaration anywhere else... |
| def_die = debug_map_symfile->FindDefinitionDIE(decl_die); |
| } |
| } |
| |
| if (log) { |
| dwarf->GetObjectFile()->GetModule()->LogMessage( |
| log, |
| "SymbolFileDWARF({0:p}) - {1:x16}}: {2} ({3}) type \"{4}\" is a " |
| "forward declaration, complete DIE is {5}", |
| static_cast<void *>(this), decl_die.GetID(), DW_TAG_value_to_name(tag), |
| tag, attrs.name.GetCString(), |
| def_die ? llvm::utohexstr(def_die.GetID()) : "not found"); |
| } |
| } |
| if (def_die) { |
| if (auto [it, inserted] = dwarf->GetDIEToType().try_emplace( |
| def_die.GetDIE(), DIE_IS_BEING_PARSED); |
| !inserted) { |
| if (it->getSecond() == nullptr || it->getSecond() == DIE_IS_BEING_PARSED) |
| return nullptr; |
| return it->getSecond()->shared_from_this(); |
| } |
| attrs = ParsedDWARFTypeAttributes(def_die); |
| } else { |
| // No definition found. Proceed with the declaration die. We can use it to |
| // create a forward-declared type. |
| def_die = decl_die; |
| } |
| |
| CompilerType enumerator_clang_type; |
| if (attrs.type.IsValid()) { |
| Type *enumerator_type = |
| dwarf->ResolveTypeUID(attrs.type.Reference(), true); |
| if (enumerator_type) |
| enumerator_clang_type = enumerator_type->GetFullCompilerType(); |
| } |
| |
| if (!enumerator_clang_type) { |
| if (attrs.byte_size) { |
| enumerator_clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize( |
| "", DW_ATE_signed, *attrs.byte_size * 8); |
| } else { |
| enumerator_clang_type = m_ast.GetBasicType(eBasicTypeInt); |
| } |
| } |
| |
| CompilerType clang_type = m_ast.CreateEnumerationType( |
| attrs.name.GetStringRef(), |
| GetClangDeclContextContainingDIE(def_die, nullptr), |
| GetOwningClangModule(def_die), attrs.decl, enumerator_clang_type, |
| attrs.is_scoped_enum, attrs.enum_kind); |
| TypeSP type_sp = |
| dwarf->MakeType(def_die.GetID(), attrs.name, attrs.byte_size, nullptr, |
| attrs.type.Reference().GetID(), Type::eEncodingIsUID, |
| &attrs.decl, clang_type, Type::ResolveState::Forward, |
| TypePayloadClang(GetOwningClangModule(def_die))); |
| |
| clang::DeclContext *type_decl_ctx = |
| TypeSystemClang::GetDeclContextForType(clang_type); |
| LinkDeclContextToDIE(type_decl_ctx, decl_die); |
| if (decl_die != def_die) { |
| LinkDeclContextToDIE(type_decl_ctx, def_die); |
| dwarf->GetDIEToType()[def_die.GetDIE()] = type_sp.get(); |
| // Declaration DIE is inserted into the type map in ParseTypeFromDWARF |
| } |
| |
| if (!CompleteEnumType(def_die, type_sp.get(), clang_type)) { |
| dwarf->GetObjectFile()->GetModule()->ReportError( |
| "DWARF DIE at {0:x16} named \"{1}\" was not able to start its " |
| "definition.\nPlease file a bug and attach the file at the " |
| "start of this error message", |
| def_die.GetOffset(), attrs.name.GetCString()); |
| } |
| return type_sp; |
| } |
| |
| static clang::CallingConv |
| ConvertDWARFCallingConventionToClang(const ParsedDWARFTypeAttributes &attrs) { |
| switch (attrs.calling_convention) { |
| case llvm::dwarf::DW_CC_normal: |
| return clang::CC_C; |
| case llvm::dwarf::DW_CC_BORLAND_stdcall: |
| return clang::CC_X86StdCall; |
| case llvm::dwarf::DW_CC_BORLAND_msfastcall: |
| return clang::CC_X86FastCall; |
| case llvm::dwarf::DW_CC_LLVM_vectorcall: |
| return clang::CC_X86VectorCall; |
| case llvm::dwarf::DW_CC_BORLAND_pascal: |
| return clang::CC_X86Pascal; |
| case llvm::dwarf::DW_CC_LLVM_Win64: |
| return clang::CC_Win64; |
| case llvm::dwarf::DW_CC_LLVM_X86_64SysV: |
| return clang::CC_X86_64SysV; |
| case llvm::dwarf::DW_CC_LLVM_X86RegCall: |
| return clang::CC_X86RegCall; |
| default: |
| break; |
| } |
| |
| Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups); |
| LLDB_LOG(log, "Unsupported DW_AT_calling_convention value: {0}", |
| attrs.calling_convention); |
| // Use the default calling convention as a fallback. |
| return clang::CC_C; |
| } |
| |
| bool DWARFASTParserClang::ParseObjCMethod( |
| const ObjCLanguage::ObjCMethodName &objc_method, const DWARFDIE &die, |
| CompilerType clang_type, const ParsedDWARFTypeAttributes &attrs, |
| bool is_variadic) { |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| assert(dwarf); |
| |
| const auto tag = die.Tag(); |
| ConstString class_name(objc_method.GetClassName()); |
| if (!class_name) |
| return false; |
| |
| TypeSP complete_objc_class_type_sp = |
| dwarf->FindCompleteObjCDefinitionTypeForDIE(DWARFDIE(), class_name, |
| false); |
| |
| if (!complete_objc_class_type_sp) |
| return false; |
| |
| CompilerType type_clang_forward_type = |
| complete_objc_class_type_sp->GetForwardCompilerType(); |
| |
| if (!type_clang_forward_type) |
| return false; |
| |
| if (!TypeSystemClang::IsObjCObjectOrInterfaceType(type_clang_forward_type)) |
| return false; |
| |
| clang::ObjCMethodDecl *objc_method_decl = m_ast.AddMethodToObjCObjectType( |
| type_clang_forward_type, attrs.name.GetCString(), clang_type, |
| attrs.is_artificial, is_variadic, attrs.is_objc_direct_call); |
| |
| if (!objc_method_decl) { |
| dwarf->GetObjectFile()->GetModule()->ReportError( |
| "[{0:x16}]: invalid Objective-C method {1:x4} ({2}), " |
| "please file a bug and attach the file at the start of " |
| "this error message", |
| die.GetOffset(), tag, DW_TAG_value_to_name(tag)); |
| return false; |
| } |
| |
| LinkDeclContextToDIE(objc_method_decl, die); |
| m_ast.SetMetadataAsUserID(objc_method_decl, die.GetID()); |
| |
| return true; |
| } |
| |
| std::pair<bool, TypeSP> DWARFASTParserClang::ParseCXXMethod( |
| const DWARFDIE &die, CompilerType clang_type, |
| const ParsedDWARFTypeAttributes &attrs, const DWARFDIE &decl_ctx_die, |
| bool is_static, bool &ignore_containing_context) { |
| Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups); |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| assert(dwarf); |
| |
| Type *class_type = dwarf->ResolveType(decl_ctx_die); |
| if (!class_type) |
| return {}; |
| |
| if (class_type->GetID() != decl_ctx_die.GetID() || |
| IsClangModuleFwdDecl(decl_ctx_die)) { |
| |
| // We uniqued the parent class of this function to another |
| // class so we now need to associate all dies under |
| // "decl_ctx_die" to DIEs in the DIE for "class_type"... |
| if (DWARFDIE class_type_die = dwarf->GetDIE(class_type->GetID())) { |
| std::vector<DWARFDIE> failures; |
| |
| CopyUniqueClassMethodTypes(decl_ctx_die, class_type_die, class_type, |
| failures); |
| |
| // FIXME do something with these failures that's |
| // smarter than just dropping them on the ground. |
| // Unfortunately classes don't like having stuff added |
| // to them after their definitions are complete... |
| |
| Type *type_ptr = dwarf->GetDIEToType().lookup(die.GetDIE()); |
| if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) |
| return {true, type_ptr->shared_from_this()}; |
| } |
| } |
| |
| if (attrs.specification.IsValid()) { |
| // We have a specification which we are going to base our |
| // function prototype off of, so we need this type to be |
| // completed so that the m_die_to_decl_ctx for the method in |
| // the specification has a valid clang decl context. |
| class_type->GetForwardCompilerType(); |
| // If we have a specification, then the function type should |
| // have been made with the specification and not with this |
| // die. |
| DWARFDIE spec_die = attrs.specification.Reference(); |
| clang::DeclContext *spec_clang_decl_ctx = |
| GetClangDeclContextForDIE(spec_die); |
| if (spec_clang_decl_ctx) |
| LinkDeclContextToDIE(spec_clang_decl_ctx, die); |
| else |
| dwarf->GetObjectFile()->GetModule()->ReportWarning( |
| "{0:x8}: DW_AT_specification({1:x16}" |
| ") has no decl\n", |
| die.GetID(), spec_die.GetOffset()); |
| |
| return {true, nullptr}; |
| } |
| |
| if (attrs.abstract_origin.IsValid()) { |
| // We have a specification which we are going to base our |
| // function prototype off of, so we need this type to be |
| // completed so that the m_die_to_decl_ctx for the method in |
| // the abstract origin has a valid clang decl context. |
| class_type->GetForwardCompilerType(); |
| |
| DWARFDIE abs_die = attrs.abstract_origin.Reference(); |
| clang::DeclContext *abs_clang_decl_ctx = GetClangDeclContextForDIE(abs_die); |
| if (abs_clang_decl_ctx) |
| LinkDeclContextToDIE(abs_clang_decl_ctx, die); |
| else |
| dwarf->GetObjectFile()->GetModule()->ReportWarning( |
| "{0:x8}: DW_AT_abstract_origin({1:x16}" |
| ") has no decl\n", |
| die.GetID(), abs_die.GetOffset()); |
| |
| return {true, nullptr}; |
| } |
| |
| CompilerType class_opaque_type = class_type->GetForwardCompilerType(); |
| if (!TypeSystemClang::IsCXXClassType(class_opaque_type)) |
| return {}; |
| |
| PrepareContextToReceiveMembers( |
| m_ast, GetClangASTImporter(), |
| TypeSystemClang::GetDeclContextForType(class_opaque_type), die, |
| attrs.name.GetCString()); |
| |
| // We have a C++ member function with no children (this pointer!) and clang |
| // will get mad if we try and make a function that isn't well formed in the |
| // DWARF, so we will just skip it... |
| if (!is_static && !die.HasChildren()) |
| return {true, nullptr}; |
| |
| const bool is_attr_used = false; |
| // Neither GCC 4.2 nor clang++ currently set a valid |
| // accessibility in the DWARF for C++ methods... |
| // Default to public for now... |
| const auto accessibility = |
| attrs.accessibility == eAccessNone ? eAccessPublic : attrs.accessibility; |
| |
| clang::CXXMethodDecl *cxx_method_decl = m_ast.AddMethodToCXXRecordType( |
| class_opaque_type.GetOpaqueQualType(), attrs.name.GetCString(), |
| attrs.mangled_name, clang_type, accessibility, attrs.is_virtual, |
| is_static, attrs.is_inline, attrs.is_explicit, is_attr_used, |
| attrs.is_artificial); |
| |
| if (cxx_method_decl) { |
| LinkDeclContextToDIE(cxx_method_decl, die); |
| |
| ClangASTMetadata metadata; |
| metadata.SetUserID(die.GetID()); |
| |
| char const *object_pointer_name = |
| attrs.object_pointer ? attrs.object_pointer.GetName() : nullptr; |
| if (object_pointer_name) { |
| metadata.SetObjectPtrName(object_pointer_name); |
| LLDB_LOGF(log, "Setting object pointer name: %s on method object %p.\n", |
| object_pointer_name, static_cast<void *>(cxx_method_decl)); |
| } |
| m_ast.SetMetadata(cxx_method_decl, metadata); |
| } else { |
| ignore_containing_context = true; |
| } |
| |
| // Artificial methods are always handled even when we |
| // don't create a new declaration for them. |
| const bool type_handled = cxx_method_decl != nullptr || attrs.is_artificial; |
| |
| return {type_handled, nullptr}; |
| } |
| |
| TypeSP |
| DWARFASTParserClang::ParseSubroutine(const DWARFDIE &die, |
| const ParsedDWARFTypeAttributes &attrs) { |
| Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups); |
| |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| const dw_tag_t tag = die.Tag(); |
| |
| bool is_variadic = false; |
| bool has_template_params = false; |
| |
| DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), |
| DW_TAG_value_to_name(tag), type_name_cstr); |
| |
| CompilerType return_clang_type; |
| Type *func_type = nullptr; |
| |
| if (attrs.type.IsValid()) |
| func_type = dwarf->ResolveTypeUID(attrs.type.Reference(), true); |
| |
| if (func_type) |
| return_clang_type = func_type->GetForwardCompilerType(); |
| else |
| return_clang_type = m_ast.GetBasicType(eBasicTypeVoid); |
| |
| std::vector<CompilerType> function_param_types; |
| llvm::SmallVector<llvm::StringRef> function_param_names; |
| |
| // Parse the function children for the parameters |
| |
| DWARFDIE decl_ctx_die; |
| clang::DeclContext *containing_decl_ctx = |
| GetClangDeclContextContainingDIE(die, &decl_ctx_die); |
| assert(containing_decl_ctx); |
| |
| if (die.HasChildren()) { |
| ParseChildParameters(containing_decl_ctx, die, is_variadic, |
| has_template_params, function_param_types, |
| function_param_names); |
| } |
| |
| bool is_cxx_method = DeclKindIsCXXClass(containing_decl_ctx->getDeclKind()); |
| bool ignore_containing_context = false; |
| // Check for templatized class member functions. If we had any |
| // DW_TAG_template_type_parameter or DW_TAG_template_value_parameter |
| // the DW_TAG_subprogram DIE, then we can't let this become a method in |
| // a class. Why? Because templatized functions are only emitted if one |
| // of the templatized methods is used in the current compile unit and |
| // we will end up with classes that may or may not include these member |
| // functions and this means one class won't match another class |
| // definition and it affects our ability to use a class in the clang |
| // expression parser. So for the greater good, we currently must not |
| // allow any template member functions in a class definition. |
| if (is_cxx_method && has_template_params) { |
| ignore_containing_context = true; |
| is_cxx_method = false; |
| } |
| |
| clang::CallingConv calling_convention = |
| ConvertDWARFCallingConventionToClang(attrs); |
| |
| const DWARFDIE object_parameter = |
| GetCXXObjectParameter(die, *containing_decl_ctx); |
| |
| // clang_type will get the function prototype clang type after this |
| // call |
| CompilerType clang_type = |
| m_ast.CreateFunctionType(return_clang_type, function_param_types.data(), |
| function_param_types.size(), is_variadic, |
| GetCXXMethodCVQuals(die, object_parameter), |
| calling_convention, attrs.ref_qual); |
| |
| if (attrs.name) { |
| bool type_handled = false; |
| if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) { |
| if (std::optional<const ObjCLanguage::ObjCMethodName> objc_method = |
| ObjCLanguage::ObjCMethodName::Create(attrs.name.GetStringRef(), |
| true)) { |
| type_handled = |
| ParseObjCMethod(*objc_method, die, clang_type, attrs, is_variadic); |
| } else if (is_cxx_method) { |
| // In DWARF, a C++ method is static if it has no object parameter child. |
| const bool is_static = !object_parameter.IsValid(); |
| auto [handled, type_sp] = |
| ParseCXXMethod(die, clang_type, attrs, decl_ctx_die, is_static, |
| ignore_containing_context); |
| if (type_sp) |
| return type_sp; |
| |
| type_handled = handled; |
| } |
| } |
| |
| if (!type_handled) { |
| clang::FunctionDecl *function_decl = nullptr; |
| clang::FunctionDecl *template_function_decl = nullptr; |
| |
| if (attrs.abstract_origin.IsValid()) { |
| DWARFDIE abs_die = attrs.abstract_origin.Reference(); |
| |
| if (dwarf->ResolveType(abs_die)) { |
| function_decl = llvm::dyn_cast_or_null<clang::FunctionDecl>( |
| GetCachedClangDeclContextForDIE(abs_die)); |
| |
| if (function_decl) { |
| LinkDeclContextToDIE(function_decl, die); |
| } |
| } |
| } |
| |
| if (!function_decl) { |
| char *name_buf = nullptr; |
| llvm::StringRef name = attrs.name.GetStringRef(); |
| |
| // We currently generate function templates with template parameters in |
| // their name. In order to get closer to the AST that clang generates |
| // we want to strip these from the name when creating the AST. |
| if (attrs.mangled_name) { |
| llvm::ItaniumPartialDemangler D; |
| if (!D.partialDemangle(attrs.mangled_name)) { |
| name_buf = D.getFunctionBaseName(nullptr, nullptr); |
| name = name_buf; |
| } |
| } |
| |
| // We just have a function that isn't part of a class |
| function_decl = m_ast.CreateFunctionDeclaration( |
| ignore_containing_context ? m_ast.GetTranslationUnitDecl() |
| : containing_decl_ctx, |
| GetOwningClangModule(die), name, clang_type, attrs.storage, |
| attrs.is_inline); |
| std::free(name_buf); |
| |
| if (has_template_params) { |
| TypeSystemClang::TemplateParameterInfos template_param_infos; |
| ParseTemplateParameterInfos(die, template_param_infos); |
| template_function_decl = m_ast.CreateFunctionDeclaration( |
| ignore_containing_context ? m_ast.GetTranslationUnitDecl() |
| : containing_decl_ctx, |
| GetOwningClangModule(die), attrs.name.GetStringRef(), clang_type, |
| attrs.storage, attrs.is_inline); |
| clang::FunctionTemplateDecl *func_template_decl = |
| m_ast.CreateFunctionTemplateDecl( |
| containing_decl_ctx, GetOwningClangModule(die), |
| template_function_decl, template_param_infos); |
| m_ast.CreateFunctionTemplateSpecializationInfo( |
| template_function_decl, func_template_decl, template_param_infos); |
| } |
| |
| lldbassert(function_decl); |
| |
| if (function_decl) { |
| // Attach an asm(<mangled_name>) label to the FunctionDecl. |
| // This ensures that clang::CodeGen emits function calls |
| // using symbols that are mangled according to the DW_AT_linkage_name. |
| // If we didn't do this, the external symbols wouldn't exactly |
| // match the mangled name LLDB knows about and the IRExecutionUnit |
| // would have to fall back to searching object files for |
| // approximately matching function names. The motivating |
| // example is generating calls to ABI-tagged template functions. |
| // This is done separately for member functions in |
| // AddMethodToCXXRecordType. |
| if (attrs.mangled_name) |
| function_decl->addAttr(clang::AsmLabelAttr::CreateImplicit( |
| m_ast.getASTContext(), attrs.mangled_name, /*literal=*/false)); |
| |
| LinkDeclContextToDIE(function_decl, die); |
| |
| const clang::FunctionProtoType *function_prototype( |
| llvm::cast<clang::FunctionProtoType>( |
| ClangUtil::GetQualType(clang_type).getTypePtr())); |
| const auto params = m_ast.CreateParameterDeclarations( |
| function_decl, *function_prototype, function_param_names); |
| function_decl->setParams(params); |
| if (template_function_decl) |
| template_function_decl->setParams(params); |
| |
| ClangASTMetadata metadata; |
| metadata.SetUserID(die.GetID()); |
| |
| char const *object_pointer_name = |
| attrs.object_pointer ? attrs.object_pointer.GetName() : nullptr; |
| if (object_pointer_name) { |
| metadata.SetObjectPtrName(object_pointer_name); |
| LLDB_LOGF(log, |
| "Setting object pointer name: %s on function " |
| "object %p.", |
| object_pointer_name, static_cast<void *>(function_decl)); |
| } |
| m_ast.SetMetadata(function_decl, metadata); |
| } |
| } |
| } |
| } |
| return dwarf->MakeType( |
| die.GetID(), attrs.name, std::nullopt, nullptr, LLDB_INVALID_UID, |
| Type::eEncodingIsUID, &attrs.decl, clang_type, Type::ResolveState::Full); |
| } |
| |
| TypeSP |
| DWARFASTParserClang::ParseArrayType(const DWARFDIE &die, |
| const ParsedDWARFTypeAttributes &attrs) { |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| |
| DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), |
| DW_TAG_value_to_name(tag), type_name_cstr); |
| |
| DWARFDIE type_die = attrs.type.Reference(); |
| Type *element_type = dwarf->ResolveTypeUID(type_die, true); |
| |
| if (!element_type) |
| return nullptr; |
| |
| std::optional<SymbolFile::ArrayInfo> array_info = ParseChildArrayInfo(die); |
| uint32_t byte_stride = attrs.byte_stride; |
| uint32_t bit_stride = attrs.bit_stride; |
| if (array_info) { |
| byte_stride = array_info->byte_stride; |
| bit_stride = array_info->bit_stride; |
| } |
| if (byte_stride == 0 && bit_stride == 0) |
| byte_stride = llvm::expectedToOptional(element_type->GetByteSize(nullptr)) |
| .value_or(0); |
| CompilerType array_element_type = element_type->GetForwardCompilerType(); |
| TypeSystemClang::RequireCompleteType(array_element_type); |
| |
| uint64_t array_element_bit_stride = byte_stride * 8 + bit_stride; |
| CompilerType clang_type; |
| if (array_info && array_info->element_orders.size() > 0) { |
| auto end = array_info->element_orders.rend(); |
| for (auto pos = array_info->element_orders.rbegin(); pos != end; ++pos) { |
| clang_type = m_ast.CreateArrayType( |
| array_element_type, /*element_count=*/*pos, attrs.is_vector); |
| |
| uint64_t num_elements = pos->value_or(0); |
| array_element_type = clang_type; |
| array_element_bit_stride = num_elements |
| ? array_element_bit_stride * num_elements |
| : array_element_bit_stride; |
| } |
| } else { |
| clang_type = m_ast.CreateArrayType( |
| array_element_type, /*element_count=*/std::nullopt, attrs.is_vector); |
| } |
| ConstString empty_name; |
| TypeSP type_sp = |
| dwarf->MakeType(die.GetID(), empty_name, array_element_bit_stride / 8, |
| nullptr, type_die.GetID(), Type::eEncodingIsUID, |
| &attrs.decl, clang_type, Type::ResolveState::Full); |
| type_sp->SetEncodingType(element_type); |
| const clang::Type *type = ClangUtil::GetQualType(clang_type).getTypePtr(); |
| m_ast.SetMetadataAsUserID(type, die.GetID()); |
| return type_sp; |
| } |
| |
| TypeSP DWARFASTParserClang::ParsePointerToMemberType( |
| const DWARFDIE &die, const ParsedDWARFTypeAttributes &attrs) { |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| Type *pointee_type = dwarf->ResolveTypeUID(attrs.type.Reference(), true); |
| Type *class_type = |
| dwarf->ResolveTypeUID(attrs.containing_type.Reference(), true); |
| |
| // Check to make sure pointers are not NULL before attempting to |
| // dereference them. |
| if ((class_type == nullptr) || (pointee_type == nullptr)) |
| return nullptr; |
| |
| CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType(); |
| CompilerType class_clang_type = class_type->GetForwardCompilerType(); |
| |
| CompilerType clang_type = TypeSystemClang::CreateMemberPointerType( |
| class_clang_type, pointee_clang_type); |
| |
| if (std::optional<uint64_t> clang_type_size = |
| llvm::expectedToOptional(clang_type.GetByteSize(nullptr))) { |
| return dwarf->MakeType(die.GetID(), attrs.name, *clang_type_size, nullptr, |
| LLDB_INVALID_UID, Type::eEncodingIsUID, nullptr, |
| clang_type, Type::ResolveState::Forward); |
| } |
| return nullptr; |
| } |
| |
| void DWARFASTParserClang::ParseInheritance( |
| const DWARFDIE &die, const DWARFDIE &parent_die, |
| const CompilerType class_clang_type, const AccessType default_accessibility, |
| const lldb::ModuleSP &module_sp, |
| std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes, |
| ClangASTImporter::LayoutInfo &layout_info) { |
| auto ast = |
| class_clang_type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>(); |
| if (ast == nullptr) |
| return; |
| |
| // TODO: implement DW_TAG_inheritance type parsing. |
| DWARFAttributes attributes = die.GetAttributes(); |
| if (attributes.Size() == 0) |
| return; |
| |
| DWARFFormValue encoding_form; |
| AccessType accessibility = default_accessibility; |
| bool is_virtual = false; |
| bool is_base_of_class = true; |
| off_t member_byte_offset = 0; |
| |
| for (uint32_t i = 0; i < attributes.Size(); ++i) { |
| const dw_attr_t attr = attributes.AttributeAtIndex(i); |
| DWARFFormValue form_value; |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) { |
| switch (attr) { |
| case DW_AT_type: |
| encoding_form = form_value; |
| break; |
| case DW_AT_data_member_location: |
| if (auto maybe_offset = |
| ExtractDataMemberLocation(die, form_value, module_sp)) |
| member_byte_offset = *maybe_offset; |
| break; |
| |
| case DW_AT_accessibility: |
| accessibility = |
| DWARFASTParser::GetAccessTypeFromDWARF(form_value.Unsigned()); |
| break; |
| |
| case DW_AT_virtuality: |
| is_virtual = form_value.Boolean(); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| } |
| |
| Type *base_class_type = die.ResolveTypeUID(encoding_form.Reference()); |
| if (base_class_type == nullptr) { |
| module_sp->ReportError("{0:x16}: DW_TAG_inheritance failed to " |
| "resolve the base class at {1:x16}" |
| " from enclosing type {2:x16}. \nPlease file " |
| "a bug and attach the file at the start of " |
| "this error message", |
| die.GetOffset(), |
| encoding_form.Reference().GetOffset(), |
| parent_die.GetOffset()); |
| return; |
| } |
| |
| CompilerType base_class_clang_type = base_class_type->GetFullCompilerType(); |
| assert(base_class_clang_type); |
| if (TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type)) { |
| ast->SetObjCSuperClass(class_clang_type, base_class_clang_type); |
| return; |
| } |
| std::unique_ptr<clang::CXXBaseSpecifier> result = |
| ast->CreateBaseClassSpecifier(base_class_clang_type.GetOpaqueQualType(), |
| accessibility, is_virtual, |
| is_base_of_class); |
| if (!result) |
| return; |
| |
| base_classes.push_back(std::move(result)); |
| |
| if (is_virtual) { |
| // Do not specify any offset for virtual inheritance. The DWARF |
| // produced by clang doesn't give us a constant offset, but gives |
| // us a DWARF expressions that requires an actual object in memory. |
| // the DW_AT_data_member_location for a virtual base class looks |
| // like: |
| // DW_AT_data_member_location( DW_OP_dup, DW_OP_deref, |
| // DW_OP_constu(0x00000018), DW_OP_minus, DW_OP_deref, |
| // DW_OP_plus ) |
| // Given this, there is really no valid response we can give to |
| // clang for virtual base class offsets, and this should eventually |
| // be removed from LayoutRecordType() in the external |
| // AST source in clang. |
| } else { |
| layout_info.base_offsets.insert(std::make_pair( |
| ast->GetAsCXXRecordDecl(base_class_clang_type.GetOpaqueQualType()), |
| clang::CharUnits::fromQuantity(member_byte_offset))); |
| } |
| } |
| |
| TypeSP DWARFASTParserClang::UpdateSymbolContextScopeForType( |
| const SymbolContext &sc, const DWARFDIE &die, TypeSP type_sp) { |
| if (!type_sp) |
| return type_sp; |
| |
| DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die); |
| dw_tag_t sc_parent_tag = sc_parent_die.Tag(); |
| |
| SymbolContextScope *symbol_context_scope = nullptr; |
| if (sc_parent_tag == DW_TAG_compile_unit || |
| sc_parent_tag == DW_TAG_partial_unit) { |
| symbol_context_scope = sc.comp_unit; |
| } else if (sc.function != nullptr && sc_parent_die) { |
| symbol_context_scope = |
| sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID()); |
| if (symbol_context_scope == nullptr) |
| symbol_context_scope = sc.function; |
| } else { |
| symbol_context_scope = sc.module_sp.get(); |
| } |
| |
| if (symbol_context_scope != nullptr) |
| type_sp->SetSymbolContextScope(symbol_context_scope); |
| return type_sp; |
| } |
| |
| void DWARFASTParserClang::GetUniqueTypeNameAndDeclaration( |
| const lldb_private::plugin::dwarf::DWARFDIE &die, |
| lldb::LanguageType language, lldb_private::ConstString &unique_typename, |
| lldb_private::Declaration &decl_declaration) { |
| // For C++, we rely solely upon the one definition rule that says |
| // only one thing can exist at a given decl context. We ignore the |
| // file and line that things are declared on. |
| if (!die.IsValid() || !Language::LanguageIsCPlusPlus(language) || |
| unique_typename.IsEmpty()) |
| return; |
| decl_declaration.Clear(); |
| std::string qualified_name; |
| DWARFDIE parent_decl_ctx_die = die.GetParentDeclContextDIE(); |
| // TODO: change this to get the correct decl context parent.... |
| while (parent_decl_ctx_die) { |
| // The name may not contain template parameters due to |
| // -gsimple-template-names; we must reconstruct the full name from child |
| // template parameter dies via GetDIEClassTemplateParams(). |
| const dw_tag_t parent_tag = parent_decl_ctx_die.Tag(); |
| switch (parent_tag) { |
| case DW_TAG_namespace: { |
| if (const char *namespace_name = parent_decl_ctx_die.GetName()) { |
| qualified_name.insert(0, "::"); |
| qualified_name.insert(0, namespace_name); |
| } else { |
| qualified_name.insert(0, "(anonymous namespace)::"); |
| } |
| parent_decl_ctx_die = parent_decl_ctx_die.GetParentDeclContextDIE(); |
| break; |
| } |
| |
| case DW_TAG_class_type: |
| case DW_TAG_structure_type: |
| case DW_TAG_union_type: { |
| if (const char *class_union_struct_name = parent_decl_ctx_die.GetName()) { |
| qualified_name.insert(0, "::"); |
| qualified_name.insert(0, |
| GetDIEClassTemplateParams(parent_decl_ctx_die)); |
| qualified_name.insert(0, class_union_struct_name); |
| } |
| parent_decl_ctx_die = parent_decl_ctx_die.GetParentDeclContextDIE(); |
| break; |
| } |
| |
| default: |
| parent_decl_ctx_die.Clear(); |
| break; |
| } |
| } |
| |
| if (qualified_name.empty()) |
| qualified_name.append("::"); |
| |
| qualified_name.append(unique_typename.GetCString()); |
| qualified_name.append(GetDIEClassTemplateParams(die)); |
| |
| unique_typename = ConstString(qualified_name); |
| } |
| |
| TypeSP |
| DWARFASTParserClang::ParseStructureLikeDIE(const SymbolContext &sc, |
| const DWARFDIE &die, |
| ParsedDWARFTypeAttributes &attrs) { |
| CompilerType clang_type; |
| const dw_tag_t tag = die.Tag(); |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU()); |
| Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups); |
| |
| ConstString unique_typename(attrs.name); |
| Declaration unique_decl(attrs.decl); |
| uint64_t byte_size = attrs.byte_size.value_or(0); |
| |
| if (attrs.name) { |
| GetUniqueTypeNameAndDeclaration(die, cu_language, unique_typename, |
| unique_decl); |
| if (log) { |
| dwarf->GetObjectFile()->GetModule()->LogMessage( |
| log, "SymbolFileDWARF({0:p}) - {1:x16}: {2} has unique name: {3} ", |
| static_cast<void *>(this), die.GetID(), DW_TAG_value_to_name(tag), |
| unique_typename.AsCString()); |
| } |
| if (UniqueDWARFASTType *unique_ast_entry_type = |
| dwarf->GetUniqueDWARFASTTypeMap().Find( |
| unique_typename, die, unique_decl, byte_size, |
| attrs.is_forward_declaration)) { |
| if (TypeSP type_sp = unique_ast_entry_type->m_type_sp) { |
| dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get(); |
| LinkDeclContextToDIE( |
| GetCachedClangDeclContextForDIE(unique_ast_entry_type->m_die), die); |
| // If the DIE being parsed in this function is a definition and the |
| // entry in the map is a declaration, then we need to update the entry |
| // to point to the definition DIE. |
| if (!attrs.is_forward_declaration && |
| unique_ast_entry_type->m_is_forward_declaration) { |
| unique_ast_entry_type->UpdateToDefDIE(die, unique_decl, byte_size); |
| clang_type = type_sp->GetForwardCompilerType(); |
| |
| CompilerType compiler_type_no_qualifiers = |
| ClangUtil::RemoveFastQualifiers(clang_type); |
| dwarf->GetForwardDeclCompilerTypeToDIE().insert_or_assign( |
| compiler_type_no_qualifiers.GetOpaqueQualType(), |
| *die.GetDIERef()); |
| } |
| return type_sp; |
| } |
| } |
| } |
| |
| DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), |
| DW_TAG_value_to_name(tag), type_name_cstr); |
| |
| int tag_decl_kind = -1; |
| AccessType default_accessibility = eAccessNone; |
| if (tag == DW_TAG_structure_type) { |
| tag_decl_kind = llvm::to_underlying(clang::TagTypeKind::Struct); |
| default_accessibility = eAccessPublic; |
| } else if (tag == DW_TAG_union_type) { |
| tag_decl_kind = llvm::to_underlying(clang::TagTypeKind::Union); |
| default_accessibility = eAccessPublic; |
| } else if (tag == DW_TAG_class_type) { |
| tag_decl_kind = llvm::to_underlying(clang::TagTypeKind::Class); |
| default_accessibility = eAccessPrivate; |
| } |
| |
| if ((attrs.class_language == eLanguageTypeObjC || |
| attrs.class_language == eLanguageTypeObjC_plus_plus) && |
| !attrs.is_complete_objc_class) { |
| // We have a valid eSymbolTypeObjCClass class symbol whose name |
| // matches the current objective C class that we are trying to find |
| // and this DIE isn't the complete definition (we checked |
| // is_complete_objc_class above and know it is false), so the real |
| // definition is in here somewhere |
| TypeSP type_sp = |
| dwarf->FindCompleteObjCDefinitionTypeForDIE(die, attrs.name, true); |
| |
| if (!type_sp) { |
| SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile(); |
| if (debug_map_symfile) { |
| // We weren't able to find a full declaration in this DWARF, |
| // see if we have a declaration anywhere else... |
| type_sp = debug_map_symfile->FindCompleteObjCDefinitionTypeForDIE( |
| die, attrs.name, true); |
| } |
| } |
| |
| if (type_sp) { |
| if (log) { |
| dwarf->GetObjectFile()->GetModule()->LogMessage( |
| log, |
| "SymbolFileDWARF({0:p}) - {1:x16}: {2} ({3}) type \"{4}\" is an " |
| "incomplete objc type, complete type is {5:x8}", |
| static_cast<void *>(this), die.GetID(), DW_TAG_value_to_name(tag), |
| tag, attrs.name.GetCString(), type_sp->GetID()); |
| } |
| return type_sp; |
| } |
| } |
| |
| if (attrs.is_forward_declaration) { |
| // See if the type comes from a Clang module and if so, track down |
| // that type. |
| TypeSP type_sp = ParseTypeFromClangModule(sc, die, log); |
| if (type_sp) |
| return type_sp; |
| } |
| |
| assert(tag_decl_kind != -1); |
| UNUSED_IF_ASSERT_DISABLED(tag_decl_kind); |
| clang::DeclContext *containing_decl_ctx = |
| GetClangDeclContextContainingDIE(die, nullptr); |
| |
| PrepareContextToReceiveMembers(m_ast, GetClangASTImporter(), |
| containing_decl_ctx, die, |
| attrs.name.GetCString()); |
| |
| if (attrs.accessibility == eAccessNone && containing_decl_ctx) { |
| // Check the decl context that contains this class/struct/union. If |
| // it is a class we must give it an accessibility. |
| const clang::Decl::Kind containing_decl_kind = |
| containing_decl_ctx->getDeclKind(); |
| if (DeclKindIsCXXClass(containing_decl_kind)) |
| attrs.accessibility = default_accessibility; |
| } |
| |
| ClangASTMetadata metadata; |
| metadata.SetUserID(die.GetID()); |
| if (!attrs.is_forward_declaration) |
| metadata.SetIsDynamicCXXType(dwarf->ClassOrStructIsVirtual(die)); |
| |
| TypeSystemClang::TemplateParameterInfos template_param_infos; |
| if (ParseTemplateParameterInfos(die, template_param_infos)) { |
| clang::ClassTemplateDecl *class_template_decl = |
| m_ast.ParseClassTemplateDecl( |
| containing_decl_ctx, GetOwningClangModule(die), attrs.accessibility, |
| attrs.name.GetCString(), tag_decl_kind, template_param_infos); |
| if (!class_template_decl) { |
| if (log) { |
| dwarf->GetObjectFile()->GetModule()->LogMessage( |
| log, |
| "SymbolFileDWARF({0:p}) - {1:x16}: {2} ({3}) type \"{4}\" " |
| "clang::ClassTemplateDecl failed to return a decl.", |
| static_cast<void *>(this), die.GetID(), DW_TAG_value_to_name(tag), |
| tag, attrs.name.GetCString()); |
| } |
| return TypeSP(); |
| } |
| |
| clang::ClassTemplateSpecializationDecl *class_specialization_decl = |
| m_ast.CreateClassTemplateSpecializationDecl( |
| containing_decl_ctx, GetOwningClangModule(die), class_template_decl, |
| tag_decl_kind, template_param_infos); |
| clang_type = |
| m_ast.CreateClassTemplateSpecializationType(class_specialization_decl); |
| |
| m_ast.SetMetadata(class_template_decl, metadata); |
| m_ast.SetMetadata(class_specialization_decl, metadata); |
| } |
| |
| if (!clang_type) { |
| clang_type = m_ast.CreateRecordType( |
| containing_decl_ctx, GetOwningClangModule(die), attrs.accessibility, |
| attrs.name.GetCString(), tag_decl_kind, attrs.class_language, metadata, |
| attrs.exports_symbols); |
| } |
| |
| TypeSP type_sp = dwarf->MakeType( |
| die.GetID(), attrs.name, attrs.byte_size, nullptr, LLDB_INVALID_UID, |
| Type::eEncodingIsUID, &attrs.decl, clang_type, |
| Type::ResolveState::Forward, |
| TypePayloadClang(OptionalClangModuleID(), attrs.is_complete_objc_class)); |
| |
| // Store a forward declaration to this class type in case any |
| // parameters in any class methods need it for the clang types for |
| // function prototypes. |
| clang::DeclContext *type_decl_ctx = |
| TypeSystemClang::GetDeclContextForType(clang_type); |
| LinkDeclContextToDIE(type_decl_ctx, die); |
| |
| // UniqueDWARFASTType is large, so don't create a local variables on the |
| // stack, put it on the heap. This function is often called recursively and |
| // clang isn't good at sharing the stack space for variables in different |
| // blocks. |
| auto unique_ast_entry_up = std::make_unique<UniqueDWARFASTType>(); |
| // Add our type to the unique type map so we don't end up creating many |
| // copies of the same type over and over in the ASTContext for our |
| // module |
| unique_ast_entry_up->m_type_sp = type_sp; |
| unique_ast_entry_up->m_die = die; |
| unique_ast_entry_up->m_declaration = unique_decl; |
| unique_ast_entry_up->m_byte_size = byte_size; |
| unique_ast_entry_up->m_is_forward_declaration = attrs.is_forward_declaration; |
| dwarf->GetUniqueDWARFASTTypeMap().Insert(unique_typename, |
| *unique_ast_entry_up); |
| |
| // Leave this as a forward declaration until we need to know the |
| // details of the type. lldb_private::Type will automatically call |
| // the SymbolFile virtual function |
| // "SymbolFileDWARF::CompleteType(Type *)" When the definition |
| // needs to be defined. |
| bool inserted = |
| dwarf->GetForwardDeclCompilerTypeToDIE() |
| .try_emplace( |
| ClangUtil::RemoveFastQualifiers(clang_type).GetOpaqueQualType(), |
| *die.GetDIERef()) |
| .second; |
| assert(inserted && "Type already in the forward declaration map!"); |
| (void)inserted; |
| m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), true); |
| |
| // If we made a clang type, set the trivial abi if applicable: We only |
| // do this for pass by value - which implies the Trivial ABI. There |
| // isn't a way to assert that something that would normally be pass by |
| // value is pass by reference, so we ignore that attribute if set. |
| if (attrs.calling_convention == llvm::dwarf::DW_CC_pass_by_value) { |
| clang::CXXRecordDecl *record_decl = |
| m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType()); |
| if (record_decl && record_decl->getDefinition()) { |
| record_decl->setHasTrivialSpecialMemberForCall(); |
| } |
| } |
| |
| if (attrs.calling_convention == llvm::dwarf::DW_CC_pass_by_reference) { |
| clang::CXXRecordDecl *record_decl = |
| m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType()); |
| if (record_decl) |
| record_decl->setArgPassingRestrictions( |
| clang::RecordArgPassingKind::CannotPassInRegs); |
| } |
| return type_sp; |
| } |
| |
| // DWARF parsing functions |
| |
| class DWARFASTParserClang::DelayedAddObjCClassProperty { |
| public: |
| DelayedAddObjCClassProperty( |
| const CompilerType &class_opaque_type, const char *property_name, |
| const CompilerType &property_opaque_type, // The property type is only |
| // required if you don't have an |
| // ivar decl |
| const char *property_setter_name, const char *property_getter_name, |
| uint32_t property_attributes, ClangASTMetadata metadata) |
| : m_class_opaque_type(class_opaque_type), m_property_name(property_name), |
| m_property_opaque_type(property_opaque_type), |
| m_property_setter_name(property_setter_name), |
| m_property_getter_name(property_getter_name), |
| m_property_attributes(property_attributes), m_metadata(metadata) {} |
| |
| bool Finalize() { |
| return TypeSystemClang::AddObjCClassProperty( |
| m_class_opaque_type, m_property_name, m_property_opaque_type, |
| /*ivar_decl=*/nullptr, m_property_setter_name, m_property_getter_name, |
| m_property_attributes, m_metadata); |
| } |
| |
| private: |
| CompilerType m_class_opaque_type; |
| const char *m_property_name; |
| CompilerType m_property_opaque_type; |
| const char *m_property_setter_name; |
| const char *m_property_getter_name; |
| uint32_t m_property_attributes; |
| ClangASTMetadata m_metadata; |
| }; |
| |
| static std::optional<clang::APValue> MakeAPValue(const clang::ASTContext &ast, |
| CompilerType clang_type, |
| uint64_t value) { |
| std::optional<uint64_t> bit_width = |
| llvm::expectedToOptional(clang_type.GetBitSize(nullptr)); |
| if (!bit_width) |
| return std::nullopt; |
| |
| bool is_signed = false; |
| const bool is_integral = clang_type.IsIntegerOrEnumerationType(is_signed); |
| |
| llvm::APSInt apint(*bit_width, !is_signed); |
| apint = value; |
| |
| if (is_integral) |
| return clang::APValue(apint); |
| |
| uint32_t count; |
| bool is_complex; |
| // FIXME: we currently support a limited set of floating point types. |
| // E.g., 16-bit floats are not supported. |
| if (!clang_type.IsFloatingPointType(count, is_complex)) |
| return std::nullopt; |
| |
| return clang::APValue(llvm::APFloat( |
| ast.getFloatTypeSemantics(ClangUtil::GetQualType(clang_type)), apint)); |
| } |
| |
| bool DWARFASTParserClang::ParseTemplateDIE( |
| const DWARFDIE &die, |
| TypeSystemClang::TemplateParameterInfos &template_param_infos) { |
| const dw_tag_t tag = die.Tag(); |
| bool is_template_template_argument = false; |
| |
| switch (tag) { |
| case DW_TAG_GNU_template_parameter_pack: { |
| template_param_infos.SetParameterPack( |
| std::make_unique<TypeSystemClang::TemplateParameterInfos>()); |
| for (DWARFDIE child_die : die.children()) { |
| if (!ParseTemplateDIE(child_die, template_param_infos.GetParameterPack())) |
| return false; |
| } |
| if (const char *name = die.GetName()) { |
| template_param_infos.SetPackName(name); |
| } |
| return true; |
| } |
| case DW_TAG_GNU_template_template_param: |
| is_template_template_argument = true; |
| [[fallthrough]]; |
| case DW_TAG_template_type_parameter: |
| case DW_TAG_template_value_parameter: { |
| DWARFAttributes attributes = die.GetAttributes(); |
| if (attributes.Size() == 0) |
| return true; |
| |
| const char *name = nullptr; |
| const char *template_name = nullptr; |
| CompilerType clang_type; |
| uint64_t uval64 = 0; |
| bool uval64_valid = false; |
| bool is_default_template_arg = false; |
| DWARFFormValue form_value; |
| for (size_t i = 0; i < attributes.Size(); ++i) { |
| const dw_attr_t attr = attributes.AttributeAtIndex(i); |
| |
| switch (attr) { |
| case DW_AT_name: |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) |
| name = form_value.AsCString(); |
| break; |
| |
| case DW_AT_GNU_template_name: |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) |
| template_name = form_value.AsCString(); |
| break; |
| |
| case DW_AT_type: |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) { |
| Type *lldb_type = die.ResolveTypeUID(form_value.Reference()); |
| if (lldb_type) |
| clang_type = lldb_type->GetForwardCompilerType(); |
| } |
| break; |
| |
| case DW_AT_const_value: |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) { |
| uval64_valid = true; |
| uval64 = form_value.Unsigned(); |
| } |
| break; |
| case DW_AT_default_value: |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) |
| is_default_template_arg = form_value.Boolean(); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| clang::ASTContext &ast = m_ast.getASTContext(); |
| if (!clang_type) |
| clang_type = m_ast.GetBasicType(eBasicTypeVoid); |
| |
| if (!is_template_template_argument) { |
| |
| if (name && !name[0]) |
| name = nullptr; |
| |
| if (tag == DW_TAG_template_value_parameter && uval64_valid) { |
| if (auto value = MakeAPValue(ast, clang_type, uval64)) { |
| template_param_infos.InsertArg( |
| name, clang::TemplateArgument( |
| ast, ClangUtil::GetQualType(clang_type), |
| std::move(*value), is_default_template_arg)); |
| return true; |
| } |
| } |
| |
| // We get here if this is a type-template parameter or we couldn't create |
| // a non-type template parameter. |
| template_param_infos.InsertArg( |
| name, clang::TemplateArgument(ClangUtil::GetQualType(clang_type), |
| /*isNullPtr*/ false, |
| is_default_template_arg)); |
| } else { |
| auto *tplt_type = m_ast.CreateTemplateTemplateParmDecl(template_name); |
| template_param_infos.InsertArg( |
| name, clang::TemplateArgument(clang::TemplateName(tplt_type), |
| is_default_template_arg)); |
| } |
| } |
| return true; |
| |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| bool DWARFASTParserClang::ParseTemplateParameterInfos( |
| const DWARFDIE &parent_die, |
| TypeSystemClang::TemplateParameterInfos &template_param_infos) { |
| |
| if (!parent_die) |
| return false; |
| |
| for (DWARFDIE die : parent_die.children()) { |
| const dw_tag_t tag = die.Tag(); |
| |
| switch (tag) { |
| case DW_TAG_template_type_parameter: |
| case DW_TAG_template_value_parameter: |
| case DW_TAG_GNU_template_parameter_pack: |
| case DW_TAG_GNU_template_template_param: |
| ParseTemplateDIE(die, template_param_infos); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| return !template_param_infos.IsEmpty() || |
| template_param_infos.hasParameterPack(); |
| } |
| |
| bool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die, |
| const CompilerType &clang_type) { |
| const dw_tag_t tag = die.Tag(); |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| |
| ClangASTImporter::LayoutInfo layout_info; |
| std::vector<DWARFDIE> contained_type_dies; |
| |
| if (die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0)) |
| return false; // No definition, cannot complete. |
| |
| // Start the definition if the type is not being defined already. This can |
| // happen (e.g.) when adding nested types to a class type -- see |
| // PrepareContextToReceiveMembers. |
| if (!clang_type.IsBeingDefined()) |
| TypeSystemClang::StartTagDeclarationDefinition(clang_type); |
| |
| AccessType default_accessibility = eAccessNone; |
| if (tag == DW_TAG_structure_type) { |
| default_accessibility = eAccessPublic; |
| } else if (tag == DW_TAG_union_type) { |
| default_accessibility = eAccessPublic; |
| } else if (tag == DW_TAG_class_type) { |
| default_accessibility = eAccessPrivate; |
| } |
| |
| std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases; |
| // Parse members and base classes first |
| std::vector<DWARFDIE> member_function_dies; |
| |
| DelayedPropertyList delayed_properties; |
| ParseChildMembers(die, clang_type, bases, member_function_dies, |
| contained_type_dies, delayed_properties, |
| default_accessibility, layout_info); |
| |
| // Now parse any methods if there were any... |
| for (const DWARFDIE &die : member_function_dies) |
| dwarf->ResolveType(die); |
| |
| if (TypeSystemClang::IsObjCObjectOrInterfaceType(clang_type)) { |
| ConstString class_name(clang_type.GetTypeName()); |
| if (class_name) { |
| dwarf->GetObjCMethods(class_name, [&](DWARFDIE method_die) { |
| method_die.ResolveType(); |
| return true; |
| }); |
| |
| for (DelayedAddObjCClassProperty &property : delayed_properties) |
| property.Finalize(); |
| } |
| } |
| |
| if (!bases.empty()) { |
| // Make sure all base classes refer to complete types and not forward |
| // declarations. If we don't do this, clang will crash with an |
| // assertion in the call to clang_type.TransferBaseClasses() |
| for (const auto &base_class : bases) { |
| clang::TypeSourceInfo *type_source_info = base_class->getTypeSourceInfo(); |
| if (type_source_info) |
| TypeSystemClang::RequireCompleteType( |
| m_ast.GetType(type_source_info->getType())); |
| } |
| |
| m_ast.TransferBaseClasses(clang_type.GetOpaqueQualType(), std::move(bases)); |
| } |
| |
| m_ast.AddMethodOverridesForCXXRecordType(clang_type.GetOpaqueQualType()); |
| TypeSystemClang::BuildIndirectFields(clang_type); |
| TypeSystemClang::CompleteTagDeclarationDefinition(clang_type); |
| |
| layout_info.bit_size = |
| die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8; |
| layout_info.alignment = |
| die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_alignment, 0) * 8; |
| |
| clang::CXXRecordDecl *record_decl = |
| m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType()); |
| if (record_decl) |
| GetClangASTImporter().SetRecordLayout(record_decl, layout_info); |
| |
| // DWARF doesn't have the attribute, but we can infer the value the same way |
| // as Clang Sema does. It's required to calculate the size of pointers to |
| // member functions of this type. |
| if (m_ast.getASTContext().getTargetInfo().getCXXABI().isMicrosoft()) { |
| auto IM = record_decl->calculateInheritanceModel(); |
| record_decl->addAttr(clang::MSInheritanceAttr::CreateImplicit( |
| m_ast.getASTContext(), true, {}, |
| clang::MSInheritanceAttr::Spelling(IM))); |
| } |
| |
| // Now parse all contained types inside of the class. We make forward |
| // declarations to all classes, but we need the CXXRecordDecl to have decls |
| // for all contained types because we don't get asked for them via the |
| // external AST support. |
| for (const DWARFDIE &die : contained_type_dies) |
| dwarf->ResolveType(die); |
| |
| return (bool)clang_type; |
| } |
| |
| bool DWARFASTParserClang::CompleteEnumType(const DWARFDIE &die, |
| lldb_private::Type *type, |
| const CompilerType &clang_type) { |
| assert(clang_type.IsEnumerationType()); |
| |
| if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) { |
| if (die.HasChildren()) |
| ParseChildEnumerators( |
| clang_type, clang_type.IsEnumerationIntegerTypeSigned(), |
| llvm::expectedToOptional(type->GetByteSize(nullptr)).value_or(0), |
| die); |
| |
| TypeSystemClang::CompleteTagDeclarationDefinition(clang_type); |
| } |
| return (bool)clang_type; |
| } |
| |
| bool DWARFASTParserClang::CompleteTypeFromDWARF( |
| const DWARFDIE &die, lldb_private::Type *type, |
| const CompilerType &clang_type) { |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| |
| std::lock_guard<std::recursive_mutex> guard( |
| dwarf->GetObjectFile()->GetModule()->GetMutex()); |
| |
| // Disable external storage for this type so we don't get anymore |
| // clang::ExternalASTSource queries for this type. |
| m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), false); |
| |
| if (!die) |
| return false; |
| |
| const dw_tag_t tag = die.Tag(); |
| |
| assert(clang_type); |
| switch (tag) { |
| case DW_TAG_structure_type: |
| case DW_TAG_union_type: |
| case DW_TAG_class_type: |
| CompleteRecordType(die, clang_type); |
| break; |
| case DW_TAG_enumeration_type: |
| CompleteEnumType(die, type, clang_type); |
| break; |
| default: |
| assert(false && "not a forward clang type decl!"); |
| break; |
| } |
| |
| // If the type is still not fully defined at this point, it means we weren't |
| // able to find its definition. We must forcefully complete it to preserve |
| // clang AST invariants. |
| if (clang_type.IsBeingDefined()) { |
| TypeSystemClang::CompleteTagDeclarationDefinition(clang_type); |
| m_ast.SetDeclIsForcefullyCompleted(ClangUtil::GetAsTagDecl(clang_type)); |
| } |
| |
| return true; |
| } |
| |
| void DWARFASTParserClang::EnsureAllDIEsInDeclContextHaveBeenParsed( |
| lldb_private::CompilerDeclContext decl_context) { |
| auto opaque_decl_ctx = |
| (clang::DeclContext *)decl_context.GetOpaqueDeclContext(); |
| for (auto it = m_decl_ctx_to_die.find(opaque_decl_ctx); |
| it != m_decl_ctx_to_die.end() && it->first == opaque_decl_ctx; |
| it = m_decl_ctx_to_die.erase(it)) |
| for (DWARFDIE decl : it->second.children()) |
| GetClangDeclForDIE(decl); |
| } |
| |
| CompilerDecl DWARFASTParserClang::GetDeclForUIDFromDWARF(const DWARFDIE &die) { |
| clang::Decl *clang_decl = GetClangDeclForDIE(die); |
| if (clang_decl != nullptr) |
| return m_ast.GetCompilerDecl(clang_decl); |
| return {}; |
| } |
| |
| CompilerDeclContext |
| DWARFASTParserClang::GetDeclContextForUIDFromDWARF(const DWARFDIE &die) { |
| clang::DeclContext *clang_decl_ctx = GetClangDeclContextForDIE(die); |
| if (clang_decl_ctx) |
| return m_ast.CreateDeclContext(clang_decl_ctx); |
| return {}; |
| } |
| |
| CompilerDeclContext |
| DWARFASTParserClang::GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) { |
| clang::DeclContext *clang_decl_ctx = |
| GetClangDeclContextContainingDIE(die, nullptr); |
| if (clang_decl_ctx) |
| return m_ast.CreateDeclContext(clang_decl_ctx); |
| return {}; |
| } |
| |
| size_t DWARFASTParserClang::ParseChildEnumerators( |
| const lldb_private::CompilerType &clang_type, bool is_signed, |
| uint32_t enumerator_byte_size, const DWARFDIE &parent_die) { |
| if (!parent_die) |
| return 0; |
| |
| size_t enumerators_added = 0; |
| |
| for (DWARFDIE die : parent_die.children()) { |
| const dw_tag_t tag = die.Tag(); |
| if (tag != DW_TAG_enumerator) |
| continue; |
| |
| DWARFAttributes attributes = die.GetAttributes(); |
| if (attributes.Size() == 0) |
| continue; |
| |
| const char *name = nullptr; |
| std::optional<uint64_t> enum_value; |
| Declaration decl; |
| |
| for (size_t i = 0; i < attributes.Size(); ++i) { |
| const dw_attr_t attr = attributes.AttributeAtIndex(i); |
| DWARFFormValue form_value; |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) { |
| switch (attr) { |
| case DW_AT_const_value: |
| if (is_signed) |
| enum_value = form_value.Signed(); |
| else |
| enum_value = form_value.Unsigned(); |
| break; |
| |
| case DW_AT_name: |
| name = form_value.AsCString(); |
| break; |
| |
| case DW_AT_description: |
| default: |
| case DW_AT_decl_file: |
| decl.SetFile( |
| attributes.CompileUnitAtIndex(i)->GetFile(form_value.Unsigned())); |
| break; |
| case DW_AT_decl_line: |
| decl.SetLine(form_value.Unsigned()); |
| break; |
| case DW_AT_decl_column: |
| decl.SetColumn(form_value.Unsigned()); |
| break; |
| case DW_AT_sibling: |
| break; |
| } |
| } |
| } |
| |
| if (name && name[0] && enum_value) { |
| m_ast.AddEnumerationValueToEnumerationType( |
| clang_type, decl, name, *enum_value, enumerator_byte_size * 8); |
| ++enumerators_added; |
| } |
| } |
| return enumerators_added; |
| } |
| |
| ConstString |
| DWARFASTParserClang::ConstructDemangledNameFromDWARF(const DWARFDIE &die) { |
| bool is_variadic = false; |
| bool has_template_params = false; |
| std::vector<CompilerType> param_types; |
| llvm::SmallVector<llvm::StringRef> param_names; |
| StreamString sstr; |
| |
| DWARFDeclContext decl_ctx = die.GetDWARFDeclContext(); |
| sstr << decl_ctx.GetQualifiedName(); |
| |
| clang::DeclContext *containing_decl_ctx = |
| GetClangDeclContextContainingDIE(die, nullptr); |
| assert(containing_decl_ctx); |
| |
| const unsigned cv_quals = GetCXXMethodCVQuals( |
| die, GetCXXObjectParameter(die, *containing_decl_ctx)); |
| |
| ParseChildParameters(containing_decl_ctx, die, is_variadic, |
| has_template_params, param_types, param_names); |
| sstr << "("; |
| for (size_t i = 0; i < param_types.size(); i++) { |
| if (i > 0) |
| sstr << ", "; |
| sstr << param_types[i].GetTypeName(); |
| } |
| if (is_variadic) |
| sstr << ", ..."; |
| sstr << ")"; |
| if (cv_quals & clang::Qualifiers::Const) |
| sstr << " const"; |
| |
| return ConstString(sstr.GetString()); |
| } |
| |
| Function *DWARFASTParserClang::ParseFunctionFromDWARF( |
| CompileUnit &comp_unit, const DWARFDIE &die, AddressRanges func_ranges) { |
| llvm::DWARFAddressRangesVector unused_func_ranges; |
| const char *name = nullptr; |
| const char *mangled = nullptr; |
| std::optional<int> decl_file; |
| std::optional<int> decl_line; |
| std::optional<int> decl_column; |
| std::optional<int> call_file; |
| std::optional<int> call_line; |
| std::optional<int> call_column; |
| DWARFExpressionList frame_base; |
| |
| const dw_tag_t tag = die.Tag(); |
| |
| if (tag != DW_TAG_subprogram) |
| return nullptr; |
| |
| if (die.GetDIENamesAndRanges(name, mangled, unused_func_ranges, decl_file, |
| decl_line, decl_column, call_file, call_line, |
| call_column, &frame_base)) { |
| Mangled func_name; |
| if (mangled) |
| func_name.SetValue(ConstString(mangled)); |
| else if ((die.GetParent().Tag() == DW_TAG_compile_unit || |
| die.GetParent().Tag() == DW_TAG_partial_unit) && |
| 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. |
| func_name.SetValue(ConstructDemangledNameFromDWARF(die)); |
| } else |
| func_name.SetValue(ConstString(name)); |
| |
| FunctionSP func_sp; |
| std::unique_ptr<Declaration> decl_up; |
| if (decl_file || decl_line || decl_column) |
| decl_up = std::make_unique<Declaration>( |
| die.GetCU()->GetFile(decl_file ? *decl_file : 0), |
| decl_line ? *decl_line : 0, decl_column ? *decl_column : 0); |
| |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| // Supply the type _only_ if it has already been parsed |
| Type *func_type = dwarf->GetDIEToType().lookup(die.GetDIE()); |
| |
| assert(func_type == nullptr || func_type != DIE_IS_BEING_PARSED); |
| |
| const user_id_t func_user_id = die.GetID(); |
| |
| // The base address of the scope for any of the debugging information |
| // entries listed above is given by either the DW_AT_low_pc attribute or the |
| // first address in the first range entry in the list of ranges given by the |
| // DW_AT_ranges attribute. |
| // -- DWARFv5, Section 2.17 Code Addresses, Ranges and Base Addresses |
| // |
| // If no DW_AT_entry_pc attribute is present, then the entry address is |
| // assumed to be the same as the base address of the containing scope. |
| // -- DWARFv5, Section 2.18 Entry Address |
| // |
| // We currently don't support Debug Info Entries with |
| // DW_AT_low_pc/DW_AT_entry_pc and DW_AT_ranges attributes (the latter |
| // attributes are ignored even though they should be used for the address of |
| // the function), but compilers also don't emit that kind of information. If |
| // this becomes a problem we need to plumb these attributes separately. |
| Address func_addr = func_ranges[0].GetBaseAddress(); |
| |
| func_sp = std::make_shared<Function>( |
| &comp_unit, |
| func_user_id, // UserID is the DIE offset |
| func_user_id, func_name, func_type, std::move(func_addr), |
| std::move(func_ranges)); |
| |
| if (func_sp.get() != nullptr) { |
| if (frame_base.IsValid()) |
| func_sp->GetFrameBaseExpression() = frame_base; |
| comp_unit.AddFunction(func_sp); |
| return func_sp.get(); |
| } |
| } |
| return nullptr; |
| } |
| |
| namespace { |
| /// Parsed form of all attributes that are relevant for parsing Objective-C |
| /// properties. |
| struct PropertyAttributes { |
| explicit PropertyAttributes(const DWARFDIE &die); |
| const char *prop_name = nullptr; |
| const char *prop_getter_name = nullptr; |
| const char *prop_setter_name = nullptr; |
| /// \see clang::ObjCPropertyAttribute |
| uint32_t prop_attributes = 0; |
| }; |
| |
| struct DiscriminantValue { |
| explicit DiscriminantValue(const DWARFDIE &die, ModuleSP module_sp); |
| |
| uint32_t byte_offset; |
| uint32_t byte_size; |
| DWARFFormValue type_ref; |
| }; |
| |
| struct VariantMember { |
| explicit VariantMember(DWARFDIE &die, ModuleSP module_sp); |
| bool IsDefault() const; |
| |
| std::optional<uint32_t> discr_value; |
| DWARFFormValue type_ref; |
| ConstString variant_name; |
| uint32_t byte_offset; |
| ConstString GetName() const; |
| }; |
| |
| struct VariantPart { |
| explicit VariantPart(const DWARFDIE &die, const DWARFDIE &parent_die, |
| ModuleSP module_sp); |
| |
| std::vector<VariantMember> &members(); |
| |
| DiscriminantValue &discriminant(); |
| |
| private: |
| std::vector<VariantMember> _members; |
| DiscriminantValue _discriminant; |
| }; |
| |
| } // namespace |
| |
| ConstString VariantMember::GetName() const { return this->variant_name; } |
| |
| bool VariantMember::IsDefault() const { return !discr_value; } |
| |
| VariantMember::VariantMember(DWARFDIE &die, lldb::ModuleSP module_sp) { |
| assert(die.Tag() == llvm::dwarf::DW_TAG_variant); |
| this->discr_value = |
| die.GetAttributeValueAsOptionalUnsigned(DW_AT_discr_value); |
| |
| for (auto child_die : die.children()) { |
| switch (child_die.Tag()) { |
| case llvm::dwarf::DW_TAG_member: { |
| DWARFAttributes attributes = child_die.GetAttributes(); |
| for (std::size_t i = 0; i < attributes.Size(); ++i) { |
| DWARFFormValue form_value; |
| const dw_attr_t attr = attributes.AttributeAtIndex(i); |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) { |
| switch (attr) { |
| case DW_AT_name: |
| variant_name = ConstString(form_value.AsCString()); |
| break; |
| case DW_AT_type: |
| type_ref = form_value; |
| break; |
| |
| case DW_AT_data_member_location: |
| if (auto maybe_offset = |
| ExtractDataMemberLocation(die, form_value, module_sp)) |
| byte_offset = *maybe_offset; |
| break; |
| |
| default: |
| break; |
| } |
| } |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| } |
| } |
| |
| DiscriminantValue::DiscriminantValue(const DWARFDIE &die, ModuleSP module_sp) { |
| auto referenced_die = die.GetReferencedDIE(DW_AT_discr); |
| DWARFAttributes attributes = referenced_die.GetAttributes(); |
| for (std::size_t i = 0; i < attributes.Size(); ++i) { |
| const dw_attr_t attr = attributes.AttributeAtIndex(i); |
| DWARFFormValue form_value; |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) { |
| switch (attr) { |
| case DW_AT_type: |
| type_ref = form_value; |
| break; |
| case DW_AT_data_member_location: |
| if (auto maybe_offset = |
| ExtractDataMemberLocation(die, form_value, module_sp)) |
| byte_offset = *maybe_offset; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| } |
| |
| VariantPart::VariantPart(const DWARFDIE &die, const DWARFDIE &parent_die, |
| lldb::ModuleSP module_sp) |
| : _members(), _discriminant(die, module_sp) { |
| |
| for (auto child : die.children()) { |
| if (child.Tag() == llvm::dwarf::DW_TAG_variant) { |
| _members.push_back(VariantMember(child, module_sp)); |
| } |
| } |
| } |
| |
| std::vector<VariantMember> &VariantPart::members() { return this->_members; } |
| |
| DiscriminantValue &VariantPart::discriminant() { return this->_discriminant; } |
| |
| DWARFASTParserClang::MemberAttributes::MemberAttributes( |
| const DWARFDIE &die, const DWARFDIE &parent_die, ModuleSP module_sp) { |
| DWARFAttributes attributes = die.GetAttributes(); |
| for (size_t i = 0; i < attributes.Size(); ++i) { |
| const dw_attr_t attr = attributes.AttributeAtIndex(i); |
| DWARFFormValue form_value; |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) { |
| switch (attr) { |
| case DW_AT_name: |
| name = form_value.AsCString(); |
| break; |
| case DW_AT_type: |
| encoding_form = form_value; |
| break; |
| case DW_AT_bit_offset: |
| bit_offset = form_value.Signed(); |
| break; |
| case DW_AT_bit_size: |
| bit_size = form_value.Unsigned(); |
| break; |
| case DW_AT_byte_size: |
| byte_size = form_value.Unsigned(); |
| break; |
| case DW_AT_const_value: |
| const_value_form = form_value; |
| break; |
| case DW_AT_data_bit_offset: |
| data_bit_offset = form_value.Unsigned(); |
| break; |
| case DW_AT_data_member_location: |
| if (auto maybe_offset = |
| ExtractDataMemberLocation(die, form_value, module_sp)) |
| member_byte_offset = *maybe_offset; |
| break; |
| |
| case DW_AT_accessibility: |
| accessibility = |
| DWARFASTParser::GetAccessTypeFromDWARF(form_value.Unsigned()); |
| break; |
| case DW_AT_artificial: |
| is_artificial = form_value.Boolean(); |
| break; |
| case DW_AT_declaration: |
| is_declaration = form_value.Boolean(); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| // Clang has a DWARF generation bug where sometimes it represents |
| // fields that are references with bad byte size and bit size/offset |
| // information such as: |
| // |
| // DW_AT_byte_size( 0x00 ) |
| // DW_AT_bit_size( 0x40 ) |
| // DW_AT_bit_offset( 0xffffffffffffffc0 ) |
| // |
| // So check the bit offset to make sure it is sane, and if the values |
| // are not sane, remove them. If we don't do this then we will end up |
| // with a crash if we try to use this type in an expression when clang |
| // becomes unhappy with its recycled debug info. |
| if (byte_size.value_or(0) == 0 && bit_offset < 0) { |
| bit_size = 0; |
| bit_offset = 0; |
| } |
| } |
| |
| PropertyAttributes::PropertyAttributes(const DWARFDIE &die) { |
| |
| DWARFAttributes attributes = die.GetAttributes(); |
| for (size_t i = 0; i < attributes.Size(); ++i) { |
| const dw_attr_t attr = attributes.AttributeAtIndex(i); |
| DWARFFormValue form_value; |
| if (attributes.ExtractFormValueAtIndex(i, form_value)) { |
| switch (attr) { |
| case DW_AT_APPLE_property_name: |
| prop_name = form_value.AsCString(); |
| break; |
| case DW_AT_APPLE_property_getter: |
| prop_getter_name = form_value.AsCString(); |
| break; |
| case DW_AT_APPLE_property_setter: |
| prop_setter_name = form_value.AsCString(); |
| break; |
| case DW_AT_APPLE_property_attribute: |
| prop_attributes = form_value.Unsigned(); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| if (!prop_name) |
| return; |
| ConstString fixed_setter; |
| |
| // Check if the property getter/setter were provided as full names. |
| // We want basenames, so we extract them. |
| if (prop_getter_name && prop_getter_name[0] == '-') { |
| std::optional<const ObjCLanguage::ObjCMethodName> prop_getter_method = |
| ObjCLanguage::ObjCMethodName::Create(prop_getter_name, true); |
| if (prop_getter_method) |
| prop_getter_name = |
| ConstString(prop_getter_method->GetSelector()).GetCString(); |
| } |
| |
| if (prop_setter_name && prop_setter_name[0] == '-') { |
| std::optional<const ObjCLanguage::ObjCMethodName> prop_setter_method = |
| ObjCLanguage::ObjCMethodName::Create(prop_setter_name, true); |
| if (prop_setter_method) |
| prop_setter_name = |
| ConstString(prop_setter_method->GetSelector()).GetCString(); |
| } |
| |
| // If the names haven't been provided, they need to be filled in. |
| if (!prop_getter_name) |
| prop_getter_name = prop_name; |
| if (!prop_setter_name && prop_name[0] && |
| !(prop_attributes & DW_APPLE_PROPERTY_readonly)) { |
| StreamString ss; |
| |
| ss.Printf("set%c%s:", toupper(prop_name[0]), &prop_name[1]); |
| |
| fixed_setter.SetString(ss.GetString()); |
| prop_setter_name = fixed_setter.GetCString(); |
| } |
| } |
| |
| void DWARFASTParserClang::ParseObjCProperty( |
| const DWARFDIE &die, const DWARFDIE &parent_die, |
| const lldb_private::CompilerType &class_clang_type, |
| DelayedPropertyList &delayed_properties) { |
| // This function can only parse DW_TAG_APPLE_property. |
| assert(die.Tag() == DW_TAG_APPLE_property); |
| |
| ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule(); |
| |
| const MemberAttributes attrs(die, parent_die, module_sp); |
| const PropertyAttributes propAttrs(die); |
| |
| if (!propAttrs.prop_name) { |
| module_sp->ReportError("{0:x8}: DW_TAG_APPLE_property has no name.", |
| die.GetID()); |
| return; |
| } |
| |
| Type *member_type = die.ResolveTypeUID(attrs.encoding_form.Reference()); |
| if (!member_type) { |
| module_sp->ReportError( |
| "{0:x8}: DW_TAG_APPLE_property '{1}' refers to type {2:x16}" |
| " which was unable to be parsed", |
| die.GetID(), propAttrs.prop_name, |
| attrs.encoding_form.Reference().GetOffset()); |
| return; |
| } |
| |
| ClangASTMetadata metadata; |
| metadata.SetUserID(die.GetID()); |
| delayed_properties.emplace_back( |
| class_clang_type, propAttrs.prop_name, |
| member_type->GetLayoutCompilerType(), propAttrs.prop_setter_name, |
| propAttrs.prop_getter_name, propAttrs.prop_attributes, metadata); |
| } |
| |
| llvm::Expected<llvm::APInt> DWARFASTParserClang::ExtractIntFromFormValue( |
| const CompilerType &int_type, const DWARFFormValue &form_value) const { |
| clang::QualType qt = ClangUtil::GetQualType(int_type); |
| assert(qt->isIntegralOrEnumerationType()); |
| auto ts_ptr = int_type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>(); |
| if (!ts_ptr) |
| return llvm::createStringError(llvm::inconvertibleErrorCode(), |
| "TypeSystem not clang"); |
| TypeSystemClang &ts = *ts_ptr; |
| clang::ASTContext &ast = ts.getASTContext(); |
| |
| const unsigned type_bits = ast.getIntWidth(qt); |
| const bool is_unsigned = qt->isUnsignedIntegerType(); |
| |
| // The maximum int size supported at the moment by this function. Limited |
| // by the uint64_t return type of DWARFFormValue::Signed/Unsigned. |
| constexpr std::size_t max_bit_size = 64; |
| |
| // For values bigger than 64 bit (e.g. __int128_t values), |
| // DWARFFormValue's Signed/Unsigned functions will return wrong results so |
| // emit an error for now. |
| if (type_bits > max_bit_size) { |
| auto msg = llvm::formatv("Can only parse integers with up to {0} bits, but " |
| "given integer has {1} bits.", |
| max_bit_size, type_bits); |
| return llvm::createStringError(llvm::inconvertibleErrorCode(), msg.str()); |
| } |
| |
| // Construct an APInt with the maximum bit size and the given integer. |
| llvm::APInt result(max_bit_size, form_value.Unsigned(), !is_unsigned); |
| |
| // Calculate how many bits are required to represent the input value. |
| // For unsigned types, take the number of active bits in the APInt. |
| // For signed types, ask APInt how many bits are required to represent the |
| // signed integer. |
| const unsigned required_bits = |
| is_unsigned ? result.getActiveBits() : result.getSignificantBits(); |
| |
| // If the input value doesn't fit into the integer type, return an error. |
| if (required_bits > type_bits) { |
| std::string value_as_str = is_unsigned |
| ? std::to_string(form_value.Unsigned()) |
| : std::to_string(form_value.Signed()); |
| auto msg = llvm::formatv("Can't store {0} value {1} in integer with {2} " |
| "bits.", |
| (is_unsigned ? "unsigned" : "signed"), |
| value_as_str, type_bits); |
| return llvm::createStringError(llvm::inconvertibleErrorCode(), msg.str()); |
| } |
| |
| // Trim the result to the bit width our the int type. |
| if (result.getBitWidth() > type_bits) |
| result = result.trunc(type_bits); |
| return result; |
| } |
| |
| void DWARFASTParserClang::CreateStaticMemberVariable( |
| const DWARFDIE &die, const MemberAttributes &attrs, |
| const lldb_private::CompilerType &class_clang_type) { |
| Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups); |
| assert(die.Tag() == DW_TAG_member || die.Tag() == DW_TAG_variable); |
| |
| Type *var_type = die.ResolveTypeUID(attrs.encoding_form.Reference()); |
| |
| if (!var_type) |
| return; |
| |
| auto accessibility = |
| attrs.accessibility == eAccessNone ? eAccessPublic : attrs.accessibility; |
| |
| CompilerType ct = var_type->GetForwardCompilerType(); |
| clang::VarDecl *v = TypeSystemClang::AddVariableToRecordType( |
| class_clang_type, attrs.name, ct, accessibility); |
| if (!v) { |
| LLDB_LOG(log, "Failed to add variable to the record type"); |
| return; |
| } |
| |
| bool unused; |
| // TODO: Support float/double static members as well. |
| if (!ct.IsIntegerOrEnumerationType(unused) || !attrs.const_value_form) |
| return; |
| |
| llvm::Expected<llvm::APInt> const_value_or_err = |
| ExtractIntFromFormValue(ct, *attrs.const_value_form); |
| if (!const_value_or_err) { |
| LLDB_LOG_ERROR(log, const_value_or_err.takeError(), |
| "Failed to add const value to variable {1}: {0}", |
| v->getQualifiedNameAsString()); |
| return; |
| } |
| |
| TypeSystemClang::SetIntegerInitializerForVariable(v, *const_value_or_err); |
| } |
| |
| void DWARFASTParserClang::ParseSingleMember( |
| const DWARFDIE &die, const DWARFDIE &parent_die, |
| const lldb_private::CompilerType &class_clang_type, |
| lldb::AccessType default_accessibility, |
| lldb_private::ClangASTImporter::LayoutInfo &layout_info, |
| FieldInfo &last_field_info) { |
| // This function can only parse DW_TAG_member. |
| assert(die.Tag() == DW_TAG_member); |
| |
| ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule(); |
| const dw_tag_t tag = die.Tag(); |
| // Get the parent byte size so we can verify any members will fit |
| const uint64_t parent_byte_size = |
| parent_die.GetAttributeValueAsUnsigned(DW_AT_byte_size, UINT64_MAX); |
| const uint64_t parent_bit_size = |
| parent_byte_size == UINT64_MAX ? UINT64_MAX : parent_byte_size * 8; |
| |
| const MemberAttributes attrs(die, parent_die, module_sp); |
| |
| // Handle static members, which are typically members without |
| // locations. However, GCC doesn't emit DW_AT_data_member_location |
| // for any union members (regardless of linkage). |
| // Non-normative text pre-DWARFv5 recommends marking static |
| // data members with an DW_AT_external flag. Clang emits this consistently |
| // whereas GCC emits it only for static data members if not part of an |
| // anonymous namespace. The flag that is consistently emitted for static |
| // data members is DW_AT_declaration, so we check it instead. |
| // The following block is only necessary to support DWARFv4 and earlier. |
| // Starting with DWARFv5, static data members are marked DW_AT_variable so we |
| // can consistently detect them on both GCC and Clang without below heuristic. |
| if (attrs.member_byte_offset == UINT32_MAX && |
| attrs.data_bit_offset == UINT64_MAX && attrs.is_declaration) { |
| CreateStaticMemberVariable(die, attrs, class_clang_type); |
| return; |
| } |
| |
| Type *member_type = die.ResolveTypeUID(attrs.encoding_form.Reference()); |
| if (!member_type) { |
| if (attrs.name) |
| module_sp->ReportError( |
| "{0:x8}: DW_TAG_member '{1}' refers to type {2:x16}" |
| " which was unable to be parsed", |
| die.GetID(), attrs.name, attrs.encoding_form.Reference().GetOffset()); |
| else |
| module_sp->ReportError("{0:x8}: DW_TAG_member refers to type {1:x16}" |
| " which was unable to be parsed", |
| die.GetID(), |
| attrs.encoding_form.Reference().GetOffset()); |
| return; |
| } |
| |
| const uint64_t character_width = 8; |
| CompilerType member_clang_type = member_type->GetLayoutCompilerType(); |
| |
| const auto accessibility = attrs.accessibility == eAccessNone |
| ? default_accessibility |
| : attrs.accessibility; |
| |
| uint64_t field_bit_offset = (attrs.member_byte_offset == UINT32_MAX |
| ? 0 |
| : (attrs.member_byte_offset * 8ULL)); |
| |
| if (attrs.bit_size > 0) { |
| FieldInfo this_field_info; |
| this_field_info.bit_offset = field_bit_offset; |
| this_field_info.bit_size = attrs.bit_size; |
| |
| if (attrs.data_bit_offset != UINT64_MAX) { |
| this_field_info.bit_offset = attrs.data_bit_offset; |
| } else { |
| auto byte_size = attrs.byte_size; |
| if (!byte_size) |
| byte_size = llvm::expectedToOptional(member_type->GetByteSize(nullptr)); |
| |
| ObjectFile *objfile = die.GetDWARF()->GetObjectFile(); |
| if (objfile->GetByteOrder() == eByteOrderLittle) { |
| this_field_info.bit_offset += byte_size.value_or(0) * 8; |
| this_field_info.bit_offset -= (attrs.bit_offset + attrs.bit_size); |
| } else { |
| this_field_info.bit_offset += attrs.bit_offset; |
| } |
| } |
| |
| // The ObjC runtime knows the byte offset but we still need to provide |
| // the bit-offset in the layout. It just means something different then |
| // what it does in C and C++. So we skip this check for ObjC types. |
| // |
| // We also skip this for fields of a union since they will all have a |
| // zero offset. |
| if (!TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type) && |
| !(parent_die.Tag() == DW_TAG_union_type && |
| this_field_info.bit_offset == 0) && |
| ((this_field_info.bit_offset >= parent_bit_size) || |
| (last_field_info.IsBitfield() && |
| !last_field_info.NextBitfieldOffsetIsValid( |
| this_field_info.bit_offset)))) { |
| ObjectFile *objfile = die.GetDWARF()->GetObjectFile(); |
| objfile->GetModule()->ReportWarning( |
| "{0:x16}: {1} ({2}) bitfield named \"{3}\" has invalid " |
| "bit offset ({4:x8}) member will be ignored. Please file a bug " |
| "against the " |
| "compiler and include the preprocessed output for {5}\n", |
| die.GetID(), DW_TAG_value_to_name(tag), tag, attrs.name, |
| this_field_info.bit_offset, GetUnitName(parent_die).c_str()); |
| return; |
| } |
| |
| // Update the field bit offset we will report for layout |
| field_bit_offset = this_field_info.bit_offset; |
| |
| // Objective-C has invalid DW_AT_bit_offset values in older |
| // versions of clang, so we have to be careful and only insert |
| // unnamed bitfields if we have a new enough clang. |
| bool detect_unnamed_bitfields = true; |
| |
| if (TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type)) |
| detect_unnamed_bitfields = |
| die.GetCU()->Supports_unnamed_objc_bitfields(); |
| |
| if (detect_unnamed_bitfields) |
| AddUnnamedBitfieldToRecordTypeIfNeeded(layout_info, class_clang_type, |
| last_field_info, this_field_info); |
| |
| last_field_info = this_field_info; |
| last_field_info.SetIsBitfield(true); |
| } else { |
| FieldInfo this_field_info; |
| this_field_info.is_bitfield = false; |
| this_field_info.bit_offset = field_bit_offset; |
| |
| // TODO: we shouldn't silently ignore the bit_size if we fail |
| // to GetByteSize. |
| if (std::optional<uint64_t> clang_type_size = |
| llvm::expectedToOptional(member_type->GetByteSize(nullptr))) { |
| this_field_info.bit_size = *clang_type_size * character_width; |
| } |
| |
| if (this_field_info.GetFieldEnd() <= last_field_info.GetEffectiveFieldEnd()) |
| this_field_info.SetEffectiveFieldEnd( |
| last_field_info.GetEffectiveFieldEnd()); |
| |
| last_field_info = this_field_info; |
| } |
| |
| // Don't turn artificial members such as vtable pointers into real FieldDecls |
| // in our AST. Clang will re-create those articial members and they would |
| // otherwise just overlap in the layout with the FieldDecls we add here. |
| // This needs to be done after updating FieldInfo which keeps track of where |
| // field start/end so we don't later try to fill the space of this |
| // artificial member with (unnamed bitfield) padding. |
| if (attrs.is_artificial && ShouldIgnoreArtificialField(attrs.name)) { |
| last_field_info.SetIsArtificial(true); |
| return; |
| } |
| |
| if (!member_clang_type.IsCompleteType()) |
| member_clang_type.GetCompleteType(); |
| |
| { |
| // Older versions of clang emit the same DWARF for array[0] and array[1]. If |
| // the current field is at the end of the structure, then there is |
| // definitely no room for extra elements and we override the type to |
| // array[0]. This was fixed by f454dfb6b5af. |
| CompilerType member_array_element_type; |
| uint64_t member_array_size; |
| bool member_array_is_incomplete; |
| |
| if (member_clang_type.IsArrayType(&member_array_element_type, |
| &member_array_size, |
| &member_array_is_incomplete) && |
| !member_array_is_incomplete) { |
| uint64_t parent_byte_size = |
| parent_die.GetAttributeValueAsUnsigned(DW_AT_byte_size, UINT64_MAX); |
| |
| if (attrs.member_byte_offset >= parent_byte_size) { |
| if (member_array_size != 1 && |
| (member_array_size != 0 || |
| attrs.member_byte_offset > parent_byte_size)) { |
| module_sp->ReportError( |
| "{0:x8}: DW_TAG_member '{1}' refers to type {2:x16}" |
| " which extends beyond the bounds of {3:x8}", |
| die.GetID(), attrs.name, |
| attrs.encoding_form.Reference().GetOffset(), parent_die.GetID()); |
| } |
| |
| member_clang_type = |
| m_ast.CreateArrayType(member_array_element_type, 0, false); |
| } |
| } |
| } |
| |
| TypeSystemClang::RequireCompleteType(member_clang_type); |
| |
| clang::FieldDecl *field_decl = TypeSystemClang::AddFieldToRecordType( |
| class_clang_type, attrs.name, member_clang_type, accessibility, |
| attrs.bit_size); |
| |
| m_ast.SetMetadataAsUserID(field_decl, die.GetID()); |
| |
| layout_info.field_offsets.insert( |
| std::make_pair(field_decl, field_bit_offset)); |
| } |
| |
| bool DWARFASTParserClang::ParseChildMembers( |
| const DWARFDIE &parent_die, const CompilerType &class_clang_type, |
| std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes, |
| std::vector<DWARFDIE> &member_function_dies, |
| std::vector<DWARFDIE> &contained_type_dies, |
| DelayedPropertyList &delayed_properties, |
| const AccessType default_accessibility, |
| ClangASTImporter::LayoutInfo &layout_info) { |
| if (!parent_die) |
| return false; |
| |
| FieldInfo last_field_info; |
| |
| ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule(); |
| auto ts = class_clang_type.GetTypeSystem(); |
| auto ast = ts.dyn_cast_or_null<TypeSystemClang>(); |
| if (ast == nullptr) |
| return false; |
| |
| for (DWARFDIE die : parent_die.children()) { |
| dw_tag_t tag = die.Tag(); |
| |
| switch (tag) { |
| case DW_TAG_APPLE_property: |
| ParseObjCProperty(die, parent_die, class_clang_type, delayed_properties); |
| break; |
| |
| case DW_TAG_variant_part: |
| if (die.GetCU()->GetDWARFLanguageType() == eLanguageTypeRust) { |
| ParseRustVariantPart(die, parent_die, class_clang_type, |
| default_accessibility, layout_info); |
| } |
| break; |
| |
| case DW_TAG_variable: { |
| const MemberAttributes attrs(die, parent_die, module_sp); |
| CreateStaticMemberVariable(die, attrs, class_clang_type); |
| } break; |
| case DW_TAG_member: |
| ParseSingleMember(die, parent_die, class_clang_type, |
| default_accessibility, layout_info, last_field_info); |
| break; |
| |
| case DW_TAG_subprogram: |
| // Let the type parsing code handle this one for us. |
| member_function_dies.push_back(die); |
| break; |
| |
| case DW_TAG_inheritance: |
| ParseInheritance(die, parent_die, class_clang_type, default_accessibility, |
| module_sp, base_classes, layout_info); |
| break; |
| |
| default: |
| if (llvm::dwarf::isType(tag)) |
| contained_type_dies.push_back(die); |
| break; |
| } |
| } |
| |
| return true; |
| } |
| |
| void DWARFASTParserClang::ParseChildParameters( |
| clang::DeclContext *containing_decl_ctx, const DWARFDIE &parent_die, |
| bool &is_variadic, bool &has_template_params, |
| std::vector<CompilerType> &function_param_types, |
| llvm::SmallVectorImpl<llvm::StringRef> &function_param_names) { |
| if (!parent_die) |
| return; |
| |
| for (DWARFDIE die : parent_die.children()) { |
| const dw_tag_t tag = die.Tag(); |
| switch (tag) { |
| case DW_TAG_formal_parameter: { |
| if (die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0)) |
| continue; |
| |
| DWARFDIE param_type_die = die.GetAttributeValueAsReferenceDIE(DW_AT_type); |
| |
| Type *type = die.ResolveTypeUID(param_type_die); |
| if (!type) |
| break; |
| |
| function_param_names.emplace_back(die.GetName()); |
| function_param_types.push_back(type->GetForwardCompilerType()); |
| } break; |
| |
| case DW_TAG_unspecified_parameters: |
| is_variadic = true; |
| break; |
| |
| case DW_TAG_template_type_parameter: |
| case DW_TAG_template_value_parameter: |
| case DW_TAG_GNU_template_parameter_pack: |
| // The one caller of this was never using the template_param_infos, and |
| // the local variable was taking up a large amount of stack space in |
| // SymbolFileDWARF::ParseType() so this was removed. If we ever need the |
| // template params back, we can add them back. |
| // ParseTemplateDIE (dwarf_cu, die, template_param_infos); |
| has_template_params = true; |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| assert(function_param_names.size() == function_param_types.size()); |
| } |
| |
| clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) { |
| if (!die) |
| return nullptr; |
| |
| switch (die.Tag()) { |
| case DW_TAG_constant: |
| case DW_TAG_formal_parameter: |
| case DW_TAG_imported_declaration: |
| case DW_TAG_imported_module: |
| break; |
| case DW_TAG_variable: |
| // This means 'die' is a C++ static data member. |
| // We don't want to create decls for such members |
| // here. |
| if (auto parent = die.GetParent(); |
| parent.IsValid() && TagIsRecordType(parent.Tag())) |
| return nullptr; |
| break; |
| default: |
| return nullptr; |
| } |
| |
| DIEToDeclMap::iterator cache_pos = m_die_to_decl.find(die.GetDIE()); |
| if (cache_pos != m_die_to_decl.end()) |
| return cache_pos->second; |
| |
| if (DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification)) { |
| clang::Decl *decl = GetClangDeclForDIE(spec_die); |
| m_die_to_decl[die.GetDIE()] = decl; |
| return decl; |
| } |
| |
| if (DWARFDIE abstract_origin_die = |
| die.GetReferencedDIE(DW_AT_abstract_origin)) { |
| clang::Decl *decl = GetClangDeclForDIE(abstract_origin_die); |
| m_die_to_decl[die.GetDIE()] = decl; |
| return decl; |
| } |
| |
| clang::Decl *decl = nullptr; |
| switch (die.Tag()) { |
| case DW_TAG_variable: |
| case DW_TAG_constant: |
| case DW_TAG_formal_parameter: { |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| Type *type = GetTypeForDIE(die); |
| if (dwarf && type) { |
| const char *name = die.GetName(); |
| clang::DeclContext *decl_context = |
| TypeSystemClang::DeclContextGetAsDeclContext( |
| dwarf->GetDeclContextContainingUID(die.GetID())); |
| decl = m_ast.CreateVariableDeclaration( |
| decl_context, GetOwningClangModule(die), name, |
| ClangUtil::GetQualType(type->GetForwardCompilerType())); |
| } |
| break; |
| } |
| case DW_TAG_imported_declaration: { |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import); |
| if (imported_uid) { |
| CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(imported_uid); |
| if (imported_decl) { |
| clang::DeclContext *decl_context = |
| TypeSystemClang::DeclContextGetAsDeclContext( |
| dwarf->GetDeclContextContainingUID(die.GetID())); |
| if (clang::NamedDecl *clang_imported_decl = |
| llvm::dyn_cast<clang::NamedDecl>( |
| (clang::Decl *)imported_decl.GetOpaqueDecl())) |
| decl = m_ast.CreateUsingDeclaration( |
| decl_context, OptionalClangModuleID(), clang_imported_decl); |
| } |
| } |
| break; |
| } |
| case DW_TAG_imported_module: { |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import); |
| |
| if (imported_uid) { |
| CompilerDeclContext imported_decl_ctx = |
| SymbolFileDWARF::GetDeclContext(imported_uid); |
| if (imported_decl_ctx) { |
| clang::DeclContext *decl_context = |
| TypeSystemClang::DeclContextGetAsDeclContext( |
| dwarf->GetDeclContextContainingUID(die.GetID())); |
| if (clang::NamespaceDecl *ns_decl = |
| TypeSystemClang::DeclContextGetAsNamespaceDecl( |
| imported_decl_ctx)) |
| decl = m_ast.CreateUsingDirectiveDeclaration( |
| decl_context, OptionalClangModuleID(), ns_decl); |
| } |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| |
| m_die_to_decl[die.GetDIE()] = decl; |
| |
| return decl; |
| } |
| |
| clang::DeclContext * |
| DWARFASTParserClang::GetClangDeclContextForDIE(const DWARFDIE &die) { |
| if (die) { |
| clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE(die); |
| if (decl_ctx) |
| return decl_ctx; |
| |
| bool try_parsing_type = true; |
| switch (die.Tag()) { |
| case DW_TAG_compile_unit: |
| case DW_TAG_partial_unit: |
| decl_ctx = m_ast.GetTranslationUnitDecl(); |
| try_parsing_type = false; |
| break; |
| |
| case DW_TAG_namespace: |
| decl_ctx = ResolveNamespaceDIE(die); |
| try_parsing_type = false; |
| break; |
| |
| case DW_TAG_imported_declaration: |
| decl_ctx = ResolveImportedDeclarationDIE(die); |
| try_parsing_type = false; |
| break; |
| |
| case DW_TAG_lexical_block: |
| decl_ctx = GetDeclContextForBlock(die); |
| try_parsing_type = false; |
| break; |
| |
| default: |
| break; |
| } |
| |
| if (decl_ctx == nullptr && try_parsing_type) { |
| Type *type = die.GetDWARF()->ResolveType(die); |
| if (type) |
| decl_ctx = GetCachedClangDeclContextForDIE(die); |
| } |
| |
| if (decl_ctx) { |
| LinkDeclContextToDIE(decl_ctx, die); |
| return decl_ctx; |
| } |
| } |
| return nullptr; |
| } |
| |
| OptionalClangModuleID |
| DWARFASTParserClang::GetOwningClangModule(const DWARFDIE &die) { |
| if (!die.IsValid()) |
| return {}; |
| |
| for (DWARFDIE parent = die.GetParent(); parent.IsValid(); |
| parent = parent.GetParent()) { |
| const dw_tag_t tag = parent.Tag(); |
| if (tag == DW_TAG_module) { |
| DWARFDIE module_die = parent; |
| auto it = m_die_to_module.find(module_die.GetDIE()); |
| if (it != m_die_to_module.end()) |
| return it->second; |
| const char *name = |
| module_die.GetAttributeValueAsString(DW_AT_name, nullptr); |
| if (!name) |
| return {}; |
| |
| OptionalClangModuleID id = |
| m_ast.GetOrCreateClangModule(name, GetOwningClangModule(module_die)); |
| m_die_to_module.insert({module_die.GetDIE(), id}); |
| return id; |
| } |
| } |
| return {}; |
| } |
| |
| static bool IsSubroutine(const DWARFDIE &die) { |
| switch (die.Tag()) { |
| case DW_TAG_subprogram: |
| case DW_TAG_inlined_subroutine: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| static DWARFDIE GetContainingFunctionWithAbstractOrigin(const DWARFDIE &die) { |
| for (DWARFDIE candidate = die; candidate; candidate = candidate.GetParent()) { |
| if (IsSubroutine(candidate)) { |
| if (candidate.GetReferencedDIE(DW_AT_abstract_origin)) { |
| return candidate; |
| } else { |
| return DWARFDIE(); |
| } |
| } |
| } |
| assert(0 && "Shouldn't call GetContainingFunctionWithAbstractOrigin on " |
| "something not in a function"); |
| return DWARFDIE(); |
| } |
| |
| static DWARFDIE FindAnyChildWithAbstractOrigin(const DWARFDIE &context) { |
| for (DWARFDIE candidate : context.children()) { |
| if (candidate.GetReferencedDIE(DW_AT_abstract_origin)) { |
| return candidate; |
| } |
| } |
| return DWARFDIE(); |
| } |
| |
| static DWARFDIE FindFirstChildWithAbstractOrigin(const DWARFDIE &block, |
| const DWARFDIE &function) { |
| assert(IsSubroutine(function)); |
| for (DWARFDIE context = block; context != function.GetParent(); |
| context = context.GetParent()) { |
| assert(!IsSubroutine(context) || context == function); |
| if (DWARFDIE child = FindAnyChildWithAbstractOrigin(context)) { |
| return child; |
| } |
| } |
| return DWARFDIE(); |
| } |
| |
| clang::DeclContext * |
| DWARFASTParserClang::GetDeclContextForBlock(const DWARFDIE &die) { |
| assert(die.Tag() == DW_TAG_lexical_block); |
| DWARFDIE containing_function_with_abstract_origin = |
| GetContainingFunctionWithAbstractOrigin(die); |
| if (!containing_function_with_abstract_origin) { |
| return (clang::DeclContext *)ResolveBlockDIE(die); |
| } |
| DWARFDIE child = FindFirstChildWithAbstractOrigin( |
| die, containing_function_with_abstract_origin); |
| CompilerDeclContext decl_context = |
| GetDeclContextContainingUIDFromDWARF(child); |
| return (clang::DeclContext *)decl_context.GetOpaqueDeclContext(); |
| } |
| |
| clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die) { |
| if (die && die.Tag() == DW_TAG_lexical_block) { |
| clang::BlockDecl *decl = |
| llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]); |
| |
| if (!decl) { |
| DWARFDIE decl_context_die; |
| clang::DeclContext *decl_context = |
| GetClangDeclContextContainingDIE(die, &decl_context_die); |
| decl = |
| m_ast.CreateBlockDeclaration(decl_context, GetOwningClangModule(die)); |
| |
| if (decl) |
| LinkDeclContextToDIE((clang::DeclContext *)decl, die); |
| } |
| |
| return decl; |
| } |
| return nullptr; |
| } |
| |
| clang::NamespaceDecl * |
| DWARFASTParserClang::ResolveNamespaceDIE(const DWARFDIE &die) { |
| if (die && die.Tag() == DW_TAG_namespace) { |
| // See if we already parsed this namespace DIE and associated it with a |
| // uniqued namespace declaration |
| clang::NamespaceDecl *namespace_decl = |
| static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]); |
| if (namespace_decl) |
| return namespace_decl; |
| else { |
| const char *namespace_name = die.GetName(); |
| clang::DeclContext *containing_decl_ctx = |
| GetClangDeclContextContainingDIE(die, nullptr); |
| bool is_inline = |
| die.GetAttributeValueAsUnsigned(DW_AT_export_symbols, 0) != 0; |
| |
| namespace_decl = m_ast.GetUniqueNamespaceDeclaration( |
| namespace_name, containing_decl_ctx, GetOwningClangModule(die), |
| is_inline); |
| |
| if (namespace_decl) |
| LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, die); |
| return namespace_decl; |
| } |
| } |
| return nullptr; |
| } |
| |
| clang::NamespaceDecl * |
| DWARFASTParserClang::ResolveImportedDeclarationDIE(const DWARFDIE &die) { |
| assert(die && die.Tag() == DW_TAG_imported_declaration); |
| |
| // See if we cached a NamespaceDecl for this imported declaration |
| // already |
| auto it = m_die_to_decl_ctx.find(die.GetDIE()); |
| if (it != m_die_to_decl_ctx.end()) |
| return static_cast<clang::NamespaceDecl *>(it->getSecond()); |
| |
| clang::NamespaceDecl *namespace_decl = nullptr; |
| |
| const DWARFDIE imported_uid = |
| die.GetAttributeValueAsReferenceDIE(DW_AT_import); |
| if (!imported_uid) |
| return nullptr; |
| |
| switch (imported_uid.Tag()) { |
| case DW_TAG_imported_declaration: |
| namespace_decl = ResolveImportedDeclarationDIE(imported_uid); |
| break; |
| case DW_TAG_namespace: |
| namespace_decl = ResolveNamespaceDIE(imported_uid); |
| break; |
| default: |
| return nullptr; |
| } |
| |
| if (!namespace_decl) |
| return nullptr; |
| |
| LinkDeclContextToDIE(namespace_decl, die); |
| |
| return namespace_decl; |
| } |
| |
| clang::DeclContext *DWARFASTParserClang::GetClangDeclContextContainingDIE( |
| const DWARFDIE &die, DWARFDIE *decl_ctx_die_copy) { |
| SymbolFileDWARF *dwarf = die.GetDWARF(); |
| |
| DWARFDIE decl_ctx_die = dwarf->GetDeclContextDIEContainingDIE(die); |
| |
| if (decl_ctx_die_copy) |
| *decl_ctx_die_copy = decl_ctx_die; |
| |
| if (decl_ctx_die) { |
| clang::DeclContext *clang_decl_ctx = |
| GetClangDeclContextForDIE(decl_ctx_die); |
| if (clang_decl_ctx) |
| return clang_decl_ctx; |
| } |
| return m_ast.GetTranslationUnitDecl(); |
| } |
| |
| clang::DeclContext * |
| DWARFASTParserClang::GetCachedClangDeclContextForDIE(const DWARFDIE &die) { |
| if (die) { |
| DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find(die.GetDIE()); |
| if (pos != m_die_to_decl_ctx.end()) |
| return pos->second; |
| } |
| return nullptr; |
| } |
| |
| void DWARFASTParserClang::LinkDeclContextToDIE(clang::DeclContext *decl_ctx, |
| const DWARFDIE &die) { |
| m_die_to_decl_ctx[die.GetDIE()] = decl_ctx; |
| // There can be many DIEs for a single decl context |
| // m_decl_ctx_to_die[decl_ctx].insert(die.GetDIE()); |
| m_decl_ctx_to_die.insert(std::make_pair(decl_ctx, die)); |
| } |
| |
| bool DWARFASTParserClang::CopyUniqueClassMethodTypes( |
| const DWARFDIE &src_class_die, const DWARFDIE &dst_class_die, |
| lldb_private::Type *class_type, std::vector<DWARFDIE> &failures) { |
| if (!class_type || !src_class_die || !dst_class_die) |
| return false; |
| if (src_class_die.Tag() != dst_class_die.Tag()) |
| return false; |
| |
| // We need to complete the class type so we can get all of the method types |
| // parsed so we can then unique those types to their equivalent counterparts |
| // in "dst_cu" and "dst_class_die" |
| class_type->GetFullCompilerType(); |
| |
| auto gather = [](DWARFDIE die, UniqueCStringMap<DWARFDIE> &map, |
| UniqueCStringMap<DWARFDIE> &map_artificial) { |
| if (die.Tag() != DW_TAG_subprogram) |
| return; |
| // Make sure this is a declaration and not a concrete instance by looking |
| // for DW_AT_declaration set to 1. Sometimes concrete function instances are |
| // placed inside the class definitions and shouldn't be included in the list |
| // of things that are tracking here. |
| if (die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) != 1) |
| return; |
| |
| if (const char *name = die.GetMangledName()) { |
| ConstString const_name(name); |
| if (die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0)) |
| map_artificial.Append(const_name, die); |
| else |
| map.Append(const_name, die); |
| } |
| }; |
| |
| UniqueCStringMap<DWARFDIE> src_name_to_die; |
| UniqueCStringMap<DWARFDIE> dst_name_to_die; |
| UniqueCStringMap<DWARFDIE> src_name_to_die_artificial; |
| UniqueCStringMap<DWARFDIE> dst_name_to_die_artificial; |
| for (DWARFDIE src_die = src_class_die.GetFirstChild(); src_die.IsValid(); |
| src_die = src_die.GetSibling()) { |
| gather(src_die, src_name_to_die, src_name_to_die_artificial); |
| } |
| for (DWARFDIE dst_die = dst_class_die.GetFirstChild(); dst_die.IsValid(); |
| dst_die = dst_die.GetSibling()) { |
| gather(dst_die, dst_name_to_die, dst_name_to_die_artificial); |
| } |
| const uint32_t src_size = src_name_to_die.GetSize(); |
| const uint32_t dst_size = dst_name_to_die.GetSize(); |
| |
| // Is everything kosher so we can go through the members at top speed? |
| bool fast_path = true; |
| |
| if (src_size != dst_size) |
| fast_path = false; |
| |
| uint32_t idx; |
| |
| if (fast_path) { |
| for (idx = 0; idx < src_size; ++idx) { |
| DWARFDIE src_die = src_name_to_die.GetValueAtIndexUnchecked(idx); |
| DWARFDIE dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx); |
| |
| if (src_die.Tag() != dst_die.Tag()) |
| fast_path = false; |
| |
| const char *src_name = src_die.GetMangledName(); |
| const char *dst_name = dst_die.GetMangledName(); |
| |
| // Make sure the names match |
| if (src_name == dst_name || (strcmp(src_name, dst_name) == 0)) |
| continue; |
| |
| fast_path = false; |
| } |
| } |
| |
| DWARFASTParserClang *src_dwarf_ast_parser = |
| static_cast<DWARFASTParserClang *>( |
| SymbolFileDWARF::GetDWARFParser(*src_class_die.GetCU())); |
| DWARFASTParserClang *dst_dwarf_ast_parser = |
| static_cast<DWARFASTParserClang *>( |
| SymbolFileDWARF::GetDWARFParser(*dst_class_die.GetCU())); |
| auto link = [&](DWARFDIE src, DWARFDIE dst) { |
| auto &die_to_type = dst_class_die.GetDWARF()->GetDIEToType(); |
| clang::DeclContext *dst_decl_ctx = |
| dst_dwarf_ast_parser->m_die_to_decl_ctx[dst.GetDIE()]; |
| if (dst_decl_ctx) |
| src_dwarf_ast_parser->LinkDeclContextToDIE(dst_decl_ctx, src); |
| |
| if (Type *src_child_type = die_to_type.lookup(src.GetDIE())) |
| die_to_type[dst.GetDIE()] = src_child_type; |
| }; |
| |
| // Now do the work of linking the DeclContexts and Types. |
| if (fast_path) { |
| // We can do this quickly. Just run across the tables index-for-index |
| // since we know each node has matching names and tags. |
| for (idx = 0; idx < src_size; ++idx) { |
| link(src_name_to_die.GetValueAtIndexUnchecked(idx), |
| dst_name_to_die.GetValueAtIndexUnchecked(idx)); |
| } |
| } else { |
| // We must do this slowly. For each member of the destination, look up a |
| // member in the source with the same name, check its tag, and unique them |
| // if everything matches up. Report failures. |
| |
| if (!src_name_to_die.IsEmpty() && !dst_name_to_die.IsEmpty()) { |
| src_name_to_die.Sort(); |
| |
| for (idx = 0; idx < dst_size; ++idx) { |
| ConstString dst_name = dst_name_to_die.GetCStringAtIndex(idx); |
| DWARFDIE dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx); |
| DWARFDIE src_die = src_name_to_die.Find(dst_name, DWARFDIE()); |
| |
| if (src_die && (src_die.Tag() == dst_die.Tag())) |
| link(src_die, dst_die); |
| else |
| failures.push_back(dst_die); |
| } |
| } |
| } |
| |
| const uint32_t src_size_artificial = src_name_to_die_artificial.GetSize(); |
| const uint32_t dst_size_artificial = dst_name_to_die_artificial.GetSize(); |
| |
| if (src_size_artificial && dst_size_artificial) { |
| dst_name_to_die_artificial.Sort(); |
| |
| for (idx = 0; idx < src_size_artificial; ++idx) { |
| ConstString src_name_artificial = |
| src_name_to_die_artificial.GetCStringAtIndex(idx); |
| DWARFDIE src_die = |
| src_name_to_die_artificial.GetValueAtIndexUnchecked(idx); |
| DWARFDIE dst_die = |
| dst_name_to_die_artificial.Find(src_name_artificial, DWARFDIE()); |
| |
| // Both classes have the artificial types, link them |
| if (dst_die) |
| link(src_die, dst_die); |
| } |
| } |
| |
| if (dst_size_artificial) { |
| for (idx = 0; idx < dst_size_artificial; ++idx) { |
| failures.push_back( |
| dst_name_to_die_artificial.GetValueAtIndexUnchecked(idx)); |
| } |
| } |
| |
| return !failures.empty(); |
| } |
| |
| bool DWARFASTParserClang::ShouldCreateUnnamedBitfield( |
| FieldInfo const &last_field_info, uint64_t last_field_end, |
| FieldInfo const &this_field_info, |
| lldb_private::ClangASTImporter::LayoutInfo const &layout_info) const { |
| // If we have a gap between the last_field_end and the current |
| // field we have an unnamed bit-field. |
| if (this_field_info.bit_offset <= last_field_end) |
| return false; |
| |
| // If we have a base class, we assume there is no unnamed |
| // bit-field if either of the following is true: |
| // (a) this is the first field since the gap can be |
| // attributed to the members from the base class. |
| // FIXME: This assumption is not correct if the first field of |
| // the derived class is indeed an unnamed bit-field. We currently |
| // do not have the machinary to track the offset of the last field |
| // of classes we have seen before, so we are not handling this case. |
| // (b) Or, the first member of the derived class was a vtable pointer. |
| // In this case we don't want to create an unnamed bitfield either |
| // since those will be inserted by clang later. |
| const bool have_base = layout_info.base_offsets.size() != 0; |
| const bool this_is_first_field = |
| last_field_info.bit_offset == 0 && last_field_info.bit_size == 0; |
| const bool first_field_is_vptr = |
| last_field_info.bit_offset == 0 && last_field_info.IsArtificial(); |
| |
| if (have_base && (this_is_first_field || first_field_is_vptr)) |
| return false; |
| |
| return true; |
| } |
| |
| void DWARFASTParserClang::AddUnnamedBitfieldToRecordTypeIfNeeded( |
| ClangASTImporter::LayoutInfo &class_layout_info, |
| const CompilerType &class_clang_type, const FieldInfo &previous_field, |
| const FieldInfo ¤t_field) { |
| // TODO: get this value from target |
| const uint64_t word_width = 32; |
| uint64_t last_field_end = previous_field.GetEffectiveFieldEnd(); |
| |
| if (!previous_field.IsBitfield()) { |
| // The last field was not a bit-field... |
| // but if it did take up the entire word then we need to extend |
| // last_field_end so the bit-field does not step into the last |
| // fields padding. |
| if (last_field_end != 0 && ((last_field_end % word_width) != 0)) |
| last_field_end += word_width - (last_field_end % word_width); |
| } |
| |
| // Nothing to be done. |
| if (!ShouldCreateUnnamedBitfield(previous_field, last_field_end, |
| current_field, class_layout_info)) |
| return; |
| |
| // Place the unnamed bitfield into the gap between the previous field's end |
| // and the current field's start. |
| const uint64_t unnamed_bit_size = current_field.bit_offset - last_field_end; |
| const uint64_t unnamed_bit_offset = last_field_end; |
| |
| clang::FieldDecl *unnamed_bitfield_decl = |
| TypeSystemClang::AddFieldToRecordType( |
| class_clang_type, llvm::StringRef(), |
| m_ast.GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, word_width), |
| lldb::AccessType::eAccessPublic, unnamed_bit_size); |
| |
| class_layout_info.field_offsets.insert( |
| std::make_pair(unnamed_bitfield_decl, unnamed_bit_offset)); |
| } |
| |
| void DWARFASTParserClang::ParseRustVariantPart( |
| DWARFDIE &die, const DWARFDIE &parent_die, |
| const CompilerType &class_clang_type, |
| const lldb::AccessType default_accesibility, |
| ClangASTImporter::LayoutInfo &layout_info) { |
| assert(die.Tag() == llvm::dwarf::DW_TAG_variant_part); |
| assert(SymbolFileDWARF::GetLanguage(*die.GetCU()) == |
| LanguageType::eLanguageTypeRust); |
| |
| ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule(); |
| |
| VariantPart variants(die, parent_die, module_sp); |
| |
| auto discriminant_type = |
| die.ResolveTypeUID(variants.discriminant().type_ref.Reference()); |
| |
| auto decl_context = m_ast.GetDeclContextForType(class_clang_type); |
| |
| auto inner_holder = m_ast.CreateRecordType( |
| decl_context, OptionalClangModuleID(), lldb::eAccessPublic, |
| std::string( |
| llvm::formatv("{0}$Inner", class_clang_type.GetTypeName(false))), |
| llvm::to_underlying(clang::TagTypeKind::Union), lldb::eLanguageTypeRust); |
| m_ast.StartTagDeclarationDefinition(inner_holder); |
| m_ast.SetIsPacked(inner_holder); |
| |
| for (auto member : variants.members()) { |
| |
| auto has_discriminant = !member.IsDefault(); |
| |
| auto member_type = die.ResolveTypeUID(member.type_ref.Reference()); |
| |
| auto field_type = m_ast.CreateRecordType( |
| m_ast.GetDeclContextForType(inner_holder), OptionalClangModuleID(), |
| lldb::eAccessPublic, |
| std::string(llvm::formatv("{0}$Variant", member.GetName())), |
| llvm::to_underlying(clang::TagTypeKind::Struct), |
| lldb::eLanguageTypeRust); |
| |
| m_ast.StartTagDeclarationDefinition(field_type); |
| auto offset = member.byte_offset; |
| |
| if (has_discriminant) { |
| m_ast.AddFieldToRecordType( |
| field_type, "$discr$", discriminant_type->GetFullCompilerType(), |
| lldb::eAccessPublic, variants.discriminant().byte_offset); |
| offset += |
| llvm::expectedToOptional(discriminant_type->GetByteSize(nullptr)) |
| .value_or(0); |
| } |
| |
| m_ast.AddFieldToRecordType(field_type, "value", |
| member_type->GetFullCompilerType(), |
| lldb::eAccessPublic, offset * 8); |
| |
| m_ast.CompleteTagDeclarationDefinition(field_type); |
| |
| auto name = has_discriminant |
| ? llvm::formatv("$variant${0}", member.discr_value.value()) |
| : std::string("$variant$"); |
| |
| auto variant_decl = |
| m_ast.AddFieldToRecordType(inner_holder, llvm::StringRef(name), |
| field_type, default_accesibility, 0); |
| |
| layout_info.field_offsets.insert({variant_decl, 0}); |
| } |
| |
| auto inner_field = m_ast.AddFieldToRecordType(class_clang_type, |
| llvm::StringRef("$variants$"), |
| inner_holder, eAccessPublic, 0); |
| |
| m_ast.CompleteTagDeclarationDefinition(inner_holder); |
| |
| layout_info.field_offsets.insert({inner_field, 0}); |
| } |
