1 //===-- DWARFDIE.h ----------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDIE_H 10 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDIE_H 11 12 #include "DWARFBaseDIE.h" 13 #include "llvm/ADT/SmallSet.h" 14 #include "llvm/ADT/iterator_range.h" 15 16 namespace lldb_private::plugin { 17 namespace dwarf { 18 class DWARFDIE : public DWARFBaseDIE { 19 public: 20 class child_iterator; 21 using DWARFBaseDIE::DWARFBaseDIE; 22 23 // Tests 24 bool IsStructUnionOrClass() const; 25 26 bool IsMethod() const; 27 28 // Accessors 29 30 // Accessing information about a DIE 31 const char *GetMangledName() const; 32 33 const char *GetPubname() const; 34 35 using DWARFBaseDIE::GetName; 36 void GetName(Stream &s) const; 37 38 void AppendTypeName(Stream &s) const; 39 40 Type *ResolveType() const; 41 42 // Resolve a type by UID using this DIE's DWARF file 43 Type *ResolveTypeUID(const DWARFDIE &die) const; 44 45 // Functions for obtaining DIE relations and references 46 47 DWARFDIE 48 GetParent() const; 49 50 DWARFDIE 51 GetFirstChild() const; 52 53 DWARFDIE 54 GetSibling() const; 55 56 DWARFDIE 57 GetReferencedDIE(const dw_attr_t attr) const; 58 59 // Get a another DIE from the same DWARF file as this DIE. This will 60 // check the current DIE's compile unit first to see if "die_offset" is 61 // in the same compile unit, and fall back to checking the DWARF file. 62 DWARFDIE 63 GetDIE(dw_offset_t die_offset) const; 64 using DWARFBaseDIE::GetDIE; 65 66 DWARFDIE 67 LookupDeepestBlock(lldb::addr_t file_addr) const; 68 69 DWARFDIE 70 GetParentDeclContextDIE() const; 71 72 /// Return this DIE's decl context as it is needed to look up types 73 /// in Clang modules. This context will include any modules or functions that 74 /// the type is declared in so an exact module match can be efficiently made. 75 std::vector<CompilerContext> GetDeclContext() const; 76 77 /// Get a context to a type so it can be looked up. 78 /// 79 /// This function uses the current DIE to fill in a CompilerContext array 80 /// that is suitable for type lookup for comparison to a TypeQuery's compiler 81 /// context (TypeQuery::GetContextRef()). If this DIE represents a named type, 82 /// it should fill out the compiler context with the type itself as the last 83 /// entry. The declaration context should be above the type and stop at an 84 /// appropriate time, like either the translation unit or at a function 85 /// context. This is designed to allow users to efficiently look for types 86 /// using a full or partial CompilerContext array. 87 std::vector<CompilerContext> GetTypeLookupContext() const; 88 89 DWARFDeclContext GetDWARFDeclContext() const; 90 91 // Getting attribute values from the DIE. 92 // 93 // GetAttributeValueAsXXX() functions should only be used if you are 94 // looking for one or two attributes on a DIE. If you are trying to 95 // parse all attributes, use GetAttributes (...) instead 96 DWARFDIE 97 GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const; 98 99 bool GetDIENamesAndRanges( 100 const char *&name, const char *&mangled, DWARFRangeList &ranges, 101 std::optional<int> &decl_file, std::optional<int> &decl_line, 102 std::optional<int> &decl_column, std::optional<int> &call_file, 103 std::optional<int> &call_line, std::optional<int> &call_column, 104 DWARFExpressionList *frame_base) const; 105 106 /// The range of all the children of this DIE. 107 llvm::iterator_range<child_iterator> children() const; 108 }; 109 110 class DWARFDIE::child_iterator 111 : public llvm::iterator_facade_base<DWARFDIE::child_iterator, 112 std::forward_iterator_tag, DWARFDIE> { 113 /// The current child or an invalid DWARFDie. 114 DWARFDIE m_die; 115 116 public: 117 child_iterator() = default; 118 child_iterator(const DWARFDIE &parent) : m_die(parent.GetFirstChild()) {} 119 bool operator==(const child_iterator &it) const { 120 // DWARFDIE's operator== differentiates between an invalid DWARFDIE that 121 // has a CU but no DIE and one that has neither CU nor DIE. The 'end' 122 // iterator could be default constructed, so explicitly allow 123 // (CU, (DIE)nullptr) == (nullptr, nullptr) -> true 124 if (!m_die.IsValid() && !it.m_die.IsValid()) 125 return true; 126 return m_die == it.m_die; 127 } 128 const DWARFDIE &operator*() const { 129 assert(m_die.IsValid() && "Derefencing invalid iterator?"); 130 return m_die; 131 } 132 DWARFDIE &operator*() { 133 assert(m_die.IsValid() && "Derefencing invalid iterator?"); 134 return m_die; 135 } 136 child_iterator &operator++() { 137 assert(m_die.IsValid() && "Incrementing invalid iterator?"); 138 m_die = m_die.GetSibling(); 139 return *this; 140 } 141 }; 142 } // namespace dwarf 143 } // namespace lldb_private::plugin 144 145 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDIE_H 146