1 //===-- DWARFDIE.cpp ------------------------------------------------------===//
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 #include "DWARFDIE.h"
10 
11 #include "DWARFASTParser.h"
12 #include "DWARFDebugInfo.h"
13 #include "DWARFDebugInfoEntry.h"
14 #include "DWARFDeclContext.h"
15 #include "DWARFUnit.h"
16 
17 using namespace lldb_private;
18 using namespace lldb_private::dwarf;
19 
20 namespace {
21 
22 /// Iterate through all DIEs elaborating (i.e. reachable by a chain of
23 /// DW_AT_specification and DW_AT_abstract_origin attributes) a given DIE. For
24 /// convenience, the starting die is included in the sequence as the first
25 /// item.
26 class ElaboratingDIEIterator
27     : public std::iterator<std::input_iterator_tag, DWARFDIE> {
28 
29   // The operating invariant is: top of m_worklist contains the "current" item
30   // and the rest of the list are items yet to be visited. An empty worklist
31   // means we've reached the end.
32   // Infinite recursion is prevented by maintaining a list of seen DIEs.
33   // Container sizes are optimized for the case of following DW_AT_specification
34   // and DW_AT_abstract_origin just once.
35   llvm::SmallVector<DWARFDIE, 2> m_worklist;
36   llvm::SmallSet<DWARFDebugInfoEntry *, 3> m_seen;
37 
38   void Next() {
39     assert(!m_worklist.empty() && "Incrementing end iterator?");
40 
41     // Pop the current item from the list.
42     DWARFDIE die = m_worklist.back();
43     m_worklist.pop_back();
44 
45     // And add back any items that elaborate it.
46     for (dw_attr_t attr : {DW_AT_specification, DW_AT_abstract_origin}) {
47       if (DWARFDIE d = die.GetReferencedDIE(attr))
48         if (m_seen.insert(die.GetDIE()).second)
49           m_worklist.push_back(d);
50     }
51   }
52 
53 public:
54   /// An iterator starting at die d.
55   explicit ElaboratingDIEIterator(DWARFDIE d) : m_worklist(1, d) {}
56 
57   /// End marker
58   ElaboratingDIEIterator() = default;
59 
60   const DWARFDIE &operator*() const { return m_worklist.back(); }
61   ElaboratingDIEIterator &operator++() {
62     Next();
63     return *this;
64   }
65   ElaboratingDIEIterator operator++(int) {
66     ElaboratingDIEIterator I = *this;
67     Next();
68     return I;
69   }
70 
71   friend bool operator==(const ElaboratingDIEIterator &a,
72                          const ElaboratingDIEIterator &b) {
73     if (a.m_worklist.empty() || b.m_worklist.empty())
74       return a.m_worklist.empty() == b.m_worklist.empty();
75     return a.m_worklist.back() == b.m_worklist.back();
76   }
77   friend bool operator!=(const ElaboratingDIEIterator &a,
78                          const ElaboratingDIEIterator &b) {
79     return !(a == b);
80   }
81 };
82 
83 llvm::iterator_range<ElaboratingDIEIterator>
84 elaborating_dies(const DWARFDIE &die) {
85   return llvm::make_range(ElaboratingDIEIterator(die),
86                           ElaboratingDIEIterator());
87 }
88 } // namespace
89 
90 DWARFDIE
91 DWARFDIE::GetParent() const {
92   if (IsValid())
93     return DWARFDIE(m_cu, m_die->GetParent());
94   else
95     return DWARFDIE();
96 }
97 
98 DWARFDIE
99 DWARFDIE::GetFirstChild() const {
100   if (IsValid())
101     return DWARFDIE(m_cu, m_die->GetFirstChild());
102   else
103     return DWARFDIE();
104 }
105 
106 DWARFDIE
107 DWARFDIE::GetSibling() const {
108   if (IsValid())
109     return DWARFDIE(m_cu, m_die->GetSibling());
110   else
111     return DWARFDIE();
112 }
113 
114 DWARFDIE
115 DWARFDIE::GetReferencedDIE(const dw_attr_t attr) const {
116   if (IsValid())
117     return m_die->GetAttributeValueAsReference(GetCU(), attr);
118   else
119     return {};
120 }
121 
122 DWARFDIE
123 DWARFDIE::GetDIE(dw_offset_t die_offset) const {
124   if (IsValid())
125     return m_cu->GetDIE(die_offset);
126   else
127     return DWARFDIE();
128 }
129 
130 DWARFDIE
131 DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
132   if (IsValid()) {
133     DWARFUnit *cu = GetCU();
134     const bool check_specification_or_abstract_origin = true;
135     DWARFFormValue form_value;
136     if (m_die->GetAttributeValue(cu, attr, form_value, nullptr,
137                                  check_specification_or_abstract_origin))
138       return form_value.Reference();
139   }
140   return DWARFDIE();
141 }
142 
143 DWARFDIE
144 DWARFDIE::LookupDeepestBlock(lldb::addr_t address) const {
145   if (!IsValid())
146     return DWARFDIE();
147 
148   DWARFDIE result;
149   bool check_children = false;
150   bool match_addr_range = false;
151   switch (Tag()) {
152   case DW_TAG_class_type:
153   case DW_TAG_namespace:
154   case DW_TAG_structure_type:
155   case DW_TAG_common_block:
156     check_children = true;
157     break;
158   case DW_TAG_compile_unit:
159   case DW_TAG_module:
160   case DW_TAG_catch_block:
161   case DW_TAG_subprogram:
162   case DW_TAG_try_block:
163   case DW_TAG_partial_unit:
164     match_addr_range = true;
165     break;
166   case DW_TAG_lexical_block:
167   case DW_TAG_inlined_subroutine:
168     check_children = true;
169     match_addr_range = true;
170     break;
171   default:
172     break;
173   }
174 
175   if (match_addr_range) {
176     DWARFRangeList ranges;
177     if (m_die->GetAttributeAddressRanges(m_cu, ranges,
178                                          /*check_hi_lo_pc=*/true) &&
179         ranges.FindEntryThatContains(address)) {
180       check_children = true;
181       switch (Tag()) {
182       default:
183         break;
184 
185       case DW_TAG_inlined_subroutine: // Inlined Function
186       case DW_TAG_lexical_block:      // Block { } in code
187         result = *this;
188         break;
189       }
190     } else {
191       check_children = false;
192     }
193   }
194 
195   if (check_children) {
196     for (DWARFDIE child : children()) {
197       if (DWARFDIE child_result = child.LookupDeepestBlock(address))
198         return child_result;
199     }
200   }
201   return result;
202 }
203 
204 const char *DWARFDIE::GetMangledName() const {
205   if (IsValid())
206     return m_die->GetMangledName(m_cu);
207   else
208     return nullptr;
209 }
210 
211 const char *DWARFDIE::GetPubname() const {
212   if (IsValid())
213     return m_die->GetPubname(m_cu);
214   else
215     return nullptr;
216 }
217 
218 const char *DWARFDIE::GetQualifiedName(std::string &storage) const {
219   if (IsValid())
220     return m_die->GetQualifiedName(m_cu, storage);
221   else
222     return nullptr;
223 }
224 
225 // GetName
226 //
227 // Get value of the DW_AT_name attribute and place that value into the supplied
228 // stream object. If the DIE is a NULL object "NULL" is placed into the stream,
229 // and if no DW_AT_name attribute exists for the DIE then nothing is printed.
230 void DWARFDIE::GetName(Stream &s) const {
231   if (!IsValid())
232     return;
233   if (GetDIE()->IsNULL()) {
234     s.PutCString("NULL");
235     return;
236   }
237   const char *name = GetDIE()->GetAttributeValueAsString(GetCU(), DW_AT_name, nullptr, true);
238   if (!name)
239     return;
240   s.PutCString(name);
241 }
242 
243 // AppendTypeName
244 //
245 // Follows the type name definition down through all needed tags to end up with
246 // a fully qualified type name and dump the results to the supplied stream.
247 // This is used to show the name of types given a type identifier.
248 void DWARFDIE::AppendTypeName(Stream &s) const {
249   if (!IsValid())
250     return;
251   if (GetDIE()->IsNULL()) {
252     s.PutCString("NULL");
253     return;
254   }
255   if (const char *name = GetPubname()) {
256     s.PutCString(name);
257     return;
258   }
259   switch (Tag()) {
260   case DW_TAG_array_type:
261     break; // print out a "[]" after printing the full type of the element
262            // below
263   case DW_TAG_base_type:
264     s.PutCString("base ");
265     break;
266   case DW_TAG_class_type:
267     s.PutCString("class ");
268     break;
269   case DW_TAG_const_type:
270     s.PutCString("const ");
271     break;
272   case DW_TAG_enumeration_type:
273     s.PutCString("enum ");
274     break;
275   case DW_TAG_file_type:
276     s.PutCString("file ");
277     break;
278   case DW_TAG_interface_type:
279     s.PutCString("interface ");
280     break;
281   case DW_TAG_packed_type:
282     s.PutCString("packed ");
283     break;
284   case DW_TAG_pointer_type:
285     break; // print out a '*' after printing the full type below
286   case DW_TAG_ptr_to_member_type:
287     break; // print out a '*' after printing the full type below
288   case DW_TAG_reference_type:
289     break; // print out a '&' after printing the full type below
290   case DW_TAG_restrict_type:
291     s.PutCString("restrict ");
292     break;
293   case DW_TAG_set_type:
294     s.PutCString("set ");
295     break;
296   case DW_TAG_shared_type:
297     s.PutCString("shared ");
298     break;
299   case DW_TAG_string_type:
300     s.PutCString("string ");
301     break;
302   case DW_TAG_structure_type:
303     s.PutCString("struct ");
304     break;
305   case DW_TAG_subrange_type:
306     s.PutCString("subrange ");
307     break;
308   case DW_TAG_subroutine_type:
309     s.PutCString("function ");
310     break;
311   case DW_TAG_thrown_type:
312     s.PutCString("thrown ");
313     break;
314   case DW_TAG_union_type:
315     s.PutCString("union ");
316     break;
317   case DW_TAG_unspecified_type:
318     s.PutCString("unspecified ");
319     break;
320   case DW_TAG_volatile_type:
321     s.PutCString("volatile ");
322     break;
323   default:
324     return;
325   }
326 
327   // Follow the DW_AT_type if possible
328   if (DWARFDIE next_die = GetAttributeValueAsReferenceDIE(DW_AT_type))
329     next_die.AppendTypeName(s);
330 
331   switch (Tag()) {
332   case DW_TAG_array_type:
333     s.PutCString("[]");
334     break;
335   case DW_TAG_pointer_type:
336     s.PutChar('*');
337     break;
338   case DW_TAG_ptr_to_member_type:
339     s.PutChar('*');
340     break;
341   case DW_TAG_reference_type:
342     s.PutChar('&');
343     break;
344   default:
345     break;
346   }
347 }
348 
349 lldb_private::Type *DWARFDIE::ResolveType() const {
350   if (IsValid())
351     return GetDWARF()->ResolveType(*this, true);
352   else
353     return nullptr;
354 }
355 
356 lldb_private::Type *DWARFDIE::ResolveTypeUID(const DWARFDIE &die) const {
357   if (SymbolFileDWARF *dwarf = GetDWARF())
358     return dwarf->ResolveTypeUID(die, true);
359   return nullptr;
360 }
361 
362 std::vector<DWARFDIE> DWARFDIE::GetDeclContextDIEs() const {
363   if (!IsValid())
364     return {};
365 
366   std::vector<DWARFDIE> result;
367   DWARFDIE parent = GetParentDeclContextDIE();
368   while (parent.IsValid() && parent.GetDIE() != GetDIE()) {
369     result.push_back(std::move(parent));
370     parent = parent.GetParentDeclContextDIE();
371   }
372 
373   return result;
374 }
375 
376 void DWARFDIE::GetDeclContext(
377     llvm::SmallVectorImpl<lldb_private::CompilerContext> &context) const {
378   const dw_tag_t tag = Tag();
379   if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
380     return;
381   DWARFDIE parent = GetParent();
382   if (parent)
383     parent.GetDeclContext(context);
384   switch (tag) {
385   case DW_TAG_module:
386     context.push_back({CompilerContextKind::Module, ConstString(GetName())});
387     break;
388   case DW_TAG_namespace:
389     context.push_back({CompilerContextKind::Namespace, ConstString(GetName())});
390     break;
391   case DW_TAG_structure_type:
392     context.push_back({CompilerContextKind::Struct, ConstString(GetName())});
393     break;
394   case DW_TAG_union_type:
395     context.push_back({CompilerContextKind::Union, ConstString(GetName())});
396     break;
397   case DW_TAG_class_type:
398     context.push_back({CompilerContextKind::Class, ConstString(GetName())});
399     break;
400   case DW_TAG_enumeration_type:
401     context.push_back({CompilerContextKind::Enum, ConstString(GetName())});
402     break;
403   case DW_TAG_subprogram:
404     context.push_back(
405         {CompilerContextKind::Function, ConstString(GetPubname())});
406     break;
407   case DW_TAG_variable:
408     context.push_back(
409         {CompilerContextKind::Variable, ConstString(GetPubname())});
410     break;
411   case DW_TAG_typedef:
412     context.push_back({CompilerContextKind::Typedef, ConstString(GetName())});
413     break;
414   default:
415     break;
416   }
417 }
418 
419 DWARFDIE
420 DWARFDIE::GetParentDeclContextDIE() const {
421   if (IsValid())
422     return m_die->GetParentDeclContextDIE(m_cu);
423   else
424     return DWARFDIE();
425 }
426 
427 bool DWARFDIE::IsStructUnionOrClass() const {
428   const dw_tag_t tag = Tag();
429   return tag == DW_TAG_class_type || tag == DW_TAG_structure_type ||
430          tag == DW_TAG_union_type;
431 }
432 
433 bool DWARFDIE::IsMethod() const {
434   for (DWARFDIE d : elaborating_dies(*this))
435     if (d.GetParent().IsStructUnionOrClass())
436       return true;
437   return false;
438 }
439 
440 bool DWARFDIE::GetDIENamesAndRanges(
441     const char *&name, const char *&mangled, DWARFRangeList &ranges,
442     int &decl_file, int &decl_line, int &decl_column, int &call_file,
443     int &call_line, int &call_column,
444     lldb_private::DWARFExpressionList *frame_base) const {
445   if (IsValid()) {
446     return m_die->GetDIENamesAndRanges(
447         GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column,
448         call_file, call_line, call_column, frame_base);
449   } else
450     return false;
451 }
452 
453 llvm::iterator_range<DWARFDIE::child_iterator> DWARFDIE::children() const {
454   return llvm::make_range(child_iterator(*this), child_iterator());
455 }
456