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   // DeclContext related functions
73   std::vector<DWARFDIE> GetDeclContextDIEs() const;
74 
75   /// Return this DIE's decl context as it is needed to look up types
76   /// in Clang modules. This context will include any modules or functions that
77   /// the type is declared in so an exact module match can be efficiently made.
78   std::vector<CompilerContext> GetDeclContext() const;
79 
80   /// Get a context to a type so it can be looked up.
81   ///
82   /// This function uses the current DIE to fill in a CompilerContext array
83   /// that is suitable for type lookup for comparison to a TypeQuery's compiler
84   /// context (TypeQuery::GetContextRef()). If this DIE represents a named type,
85   /// it should fill out the compiler context with the type itself as the last
86   /// entry. The declaration context should be above the type and stop at an
87   /// appropriate time, like either the translation unit or at a function
88   /// context. This is designed to allow users to efficiently look for types
89   /// using a full or partial CompilerContext array.
90   std::vector<CompilerContext> GetTypeLookupContext() const;
91 
92   // Getting attribute values from the DIE.
93   //
94   // GetAttributeValueAsXXX() functions should only be used if you are
95   // looking for one or two attributes on a DIE. If you are trying to
96   // parse all attributes, use GetAttributes (...) instead
97   DWARFDIE
98   GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const;
99 
100   bool GetDIENamesAndRanges(
101       const char *&name, const char *&mangled, DWARFRangeList &ranges,
102       std::optional<int> &decl_file, std::optional<int> &decl_line,
103       std::optional<int> &decl_column, std::optional<int> &call_file,
104       std::optional<int> &call_line, std::optional<int> &call_column,
105       DWARFExpressionList *frame_base) const;
106 
107   /// The range of all the children of this DIE.
108   llvm::iterator_range<child_iterator> children() const;
109 };
110 
111 class DWARFDIE::child_iterator
112     : public llvm::iterator_facade_base<DWARFDIE::child_iterator,
113                                         std::forward_iterator_tag, DWARFDIE> {
114   /// The current child or an invalid DWARFDie.
115   DWARFDIE m_die;
116 
117 public:
118   child_iterator() = default;
119   child_iterator(const DWARFDIE &parent) : m_die(parent.GetFirstChild()) {}
120   bool operator==(const child_iterator &it) const {
121     // DWARFDIE's operator== differentiates between an invalid DWARFDIE that
122     // has a CU but no DIE and one that has neither CU nor DIE. The 'end'
123     // iterator could be default constructed, so explicitly allow
124     // (CU, (DIE)nullptr) == (nullptr, nullptr) -> true
125     if (!m_die.IsValid() && !it.m_die.IsValid())
126       return true;
127     return m_die == it.m_die;
128   }
129   const DWARFDIE &operator*() const {
130     assert(m_die.IsValid() && "Derefencing invalid iterator?");
131     return m_die;
132   }
133   DWARFDIE &operator*() {
134     assert(m_die.IsValid() && "Derefencing invalid iterator?");
135     return m_die;
136   }
137   child_iterator &operator++() {
138     assert(m_die.IsValid() && "Incrementing invalid iterator?");
139     m_die = m_die.GetSibling();
140     return *this;
141   }
142 };
143 } // namespace dwarf
144 } // namespace lldb_private::plugin
145 
146 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDIE_H
147