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
Next()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.
ElaboratingDIEIterator(DWARFDIE d)55 explicit ElaboratingDIEIterator(DWARFDIE d) : m_worklist(1, d) {}
56
57 /// End marker
58 ElaboratingDIEIterator() = default;
59
operator *() const60 const DWARFDIE &operator*() const { return m_worklist.back(); }
operator ++()61 ElaboratingDIEIterator &operator++() {
62 Next();
63 return *this;
64 }
operator ++(int)65 ElaboratingDIEIterator operator++(int) {
66 ElaboratingDIEIterator I = *this;
67 Next();
68 return I;
69 }
70
operator ==(const ElaboratingDIEIterator & a,const ElaboratingDIEIterator & b)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 }
operator !=(const ElaboratingDIEIterator & a,const ElaboratingDIEIterator & b)77 friend bool operator!=(const ElaboratingDIEIterator &a,
78 const ElaboratingDIEIterator &b) {
79 return !(a == b);
80 }
81 };
82
83 llvm::iterator_range<ElaboratingDIEIterator>
elaborating_dies(const DWARFDIE & die)84 elaborating_dies(const DWARFDIE &die) {
85 return llvm::make_range(ElaboratingDIEIterator(die),
86 ElaboratingDIEIterator());
87 }
88 } // namespace
89
90 DWARFDIE
GetParent() const91 DWARFDIE::GetParent() const {
92 if (IsValid())
93 return DWARFDIE(m_cu, m_die->GetParent());
94 else
95 return DWARFDIE();
96 }
97
98 DWARFDIE
GetFirstChild() const99 DWARFDIE::GetFirstChild() const {
100 if (IsValid())
101 return DWARFDIE(m_cu, m_die->GetFirstChild());
102 else
103 return DWARFDIE();
104 }
105
106 DWARFDIE
GetSibling() const107 DWARFDIE::GetSibling() const {
108 if (IsValid())
109 return DWARFDIE(m_cu, m_die->GetSibling());
110 else
111 return DWARFDIE();
112 }
113
114 DWARFDIE
GetReferencedDIE(const dw_attr_t attr) const115 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
GetDIE(dw_offset_t die_offset) const123 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
GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const131 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
LookupDeepestBlock(lldb::addr_t address) const144 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
GetMangledName() const204 const char *DWARFDIE::GetMangledName() const {
205 if (IsValid())
206 return m_die->GetMangledName(m_cu);
207 else
208 return nullptr;
209 }
210
GetPubname() const211 const char *DWARFDIE::GetPubname() const {
212 if (IsValid())
213 return m_die->GetPubname(m_cu);
214 else
215 return nullptr;
216 }
217
GetQualifiedName(std::string & storage) const218 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.
GetName(Stream & s) const230 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.
AppendTypeName(Stream & s) const248 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
ResolveType() const349 lldb_private::Type *DWARFDIE::ResolveType() const {
350 if (IsValid())
351 return GetDWARF()->ResolveType(*this, true);
352 else
353 return nullptr;
354 }
355
ResolveTypeUID(const DWARFDIE & die) const356 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
GetDeclContextDIEs() const362 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
GetDeclContext(llvm::SmallVectorImpl<lldb_private::CompilerContext> & context) const376 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
GetParentDeclContextDIE() const420 DWARFDIE::GetParentDeclContextDIE() const {
421 if (IsValid())
422 return m_die->GetParentDeclContextDIE(m_cu);
423 else
424 return DWARFDIE();
425 }
426
IsStructUnionOrClass() const427 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
IsMethod() const433 bool DWARFDIE::IsMethod() const {
434 for (DWARFDIE d : elaborating_dies(*this))
435 if (d.GetParent().IsStructUnionOrClass())
436 return true;
437 return false;
438 }
439
GetDIENamesAndRanges(const char * & name,const char * & mangled,DWARFRangeList & ranges,int & decl_file,int & decl_line,int & decl_column,int & call_file,int & call_line,int & call_column,lldb_private::DWARFExpressionList * frame_base) const440 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
children() const453 llvm::iterator_range<DWARFDIE::child_iterator> DWARFDIE::children() const {
454 return llvm::make_range(child_iterator(*this), child_iterator());
455 }
456