LLDB mainline
DWARFDIE.cpp
Go to the documentation of this file.
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#include "LogChannelDWARF.h"
17#include "lldb/Symbol/Type.h"
18
19#include "llvm/ADT/iterator.h"
20#include "llvm/BinaryFormat/Dwarf.h"
21#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
22
23using namespace lldb_private;
24using namespace lldb_private::dwarf;
25using namespace lldb_private::plugin::dwarf;
26
27namespace {
28
29/// Iterate through all DIEs elaborating (i.e. reachable by a chain of
30/// DW_AT_specification, DW_AT_abstract_origin and/or DW_AT_signature
31/// attributes) a given DIE. For convenience, the starting die is included in
32/// the sequence as the first item.
33class ElaboratingDIEIterator
34 : public llvm::iterator_facade_base<
35 ElaboratingDIEIterator, std::input_iterator_tag, DWARFDIE,
36 std::ptrdiff_t, DWARFDIE *, DWARFDIE *> {
37
38 // The operating invariant is: top of m_worklist contains the "current" item
39 // and the rest of the list are items yet to be visited. An empty worklist
40 // means we've reached the end.
41 // Infinite recursion is prevented by maintaining a list of seen DIEs.
42 // Container sizes are optimized for the case of following DW_AT_specification
43 // and DW_AT_abstract_origin just once.
44 llvm::SmallVector<DWARFDIE, 2> m_worklist;
45 llvm::SmallSet<DWARFDebugInfoEntry *, 3> m_seen;
46
47 void Next() {
48 assert(!m_worklist.empty() && "Incrementing end iterator?");
49
50 // Pop the current item from the list.
51 DWARFDIE die = m_worklist.back();
52 m_worklist.pop_back();
53
54 // And add back any items that elaborate it.
55 for (dw_attr_t attr :
56 {DW_AT_specification, DW_AT_abstract_origin, DW_AT_signature}) {
57 if (DWARFDIE d = die.GetReferencedDIE(attr))
58 if (m_seen.insert(die.GetDIE()).second)
59 m_worklist.push_back(d);
60 }
61 }
62
63public:
64 /// An iterator starting at die d.
65 explicit ElaboratingDIEIterator(DWARFDIE d) : m_worklist(1, d) {}
66
67 /// End marker
68 ElaboratingDIEIterator() = default;
69
70 const DWARFDIE &operator*() const { return m_worklist.back(); }
71 ElaboratingDIEIterator &operator++() {
72 Next();
73 return *this;
74 }
75
76 friend bool operator==(const ElaboratingDIEIterator &a,
77 const ElaboratingDIEIterator &b) {
78 if (a.m_worklist.empty() || b.m_worklist.empty())
79 return a.m_worklist.empty() == b.m_worklist.empty();
80 return a.m_worklist.back() == b.m_worklist.back();
81 }
82};
83
84llvm::iterator_range<ElaboratingDIEIterator>
85elaborating_dies(const DWARFDIE &die) {
86 return llvm::make_range(ElaboratingDIEIterator(die),
87 ElaboratingDIEIterator());
88}
89} // namespace
90
93 if (IsValid())
94 return DWARFDIE(m_cu, m_die->GetParent());
95 else
96 return DWARFDIE();
97}
98
101 if (IsValid())
102 return DWARFDIE(m_cu, m_die->GetFirstChild());
103 else
104 return DWARFDIE();
105}
106
109 if (IsValid())
110 return DWARFDIE(m_cu, m_die->GetSibling());
111 else
112 return DWARFDIE();
113}
114
117 if (IsValid())
119 else
120 return {};
121}
122
124DWARFDIE::GetDIE(dw_offset_t die_offset) const {
125 if (IsValid())
126 return m_cu->GetDIE(die_offset);
127 else
128 return DWARFDIE();
129}
130
133 if (IsValid()) {
134 DWARFUnit *cu = GetCU();
135 const bool check_elaborating_dies = true;
136 DWARFFormValue form_value;
137 if (m_die->GetAttributeValue(cu, attr, form_value, nullptr,
138 check_elaborating_dies))
139 return form_value.Reference();
140 }
141 return DWARFDIE();
142}
143
146 if (!IsValid())
147 return DWARFDIE();
148
149 DWARFDIE result;
150 bool check_children = false;
151 bool match_addr_range = false;
152 switch (Tag()) {
153 case DW_TAG_class_type:
154 case DW_TAG_namespace:
155 case DW_TAG_structure_type:
156 case DW_TAG_common_block:
157 check_children = true;
158 break;
159 case DW_TAG_compile_unit:
160 case DW_TAG_module:
161 case DW_TAG_catch_block:
162 case DW_TAG_subprogram:
163 case DW_TAG_try_block:
164 case DW_TAG_partial_unit:
165 match_addr_range = true;
166 break;
167 case DW_TAG_lexical_block:
168 case DW_TAG_inlined_subroutine:
169 check_children = true;
170 match_addr_range = true;
171 break;
172 default:
173 break;
174 }
175
176 if (match_addr_range) {
177 if (llvm::Expected<llvm::DWARFAddressRangesVector> ranges =
178 m_die->GetAttributeAddressRanges(m_cu, /*check_hi_lo_pc=*/true)) {
179 bool addr_in_range =
180 llvm::any_of(*ranges, [&](const llvm::DWARFAddressRange &r) {
181 return r.LowPC <= address && address < r.HighPC;
182 });
183 if (addr_in_range) {
184 switch (Tag()) {
185 default:
186 break;
187
188 case DW_TAG_inlined_subroutine: // Inlined Function
189 case DW_TAG_lexical_block: // Block { } in code
190 result = *this;
191 break;
192 }
193 }
194 check_children = addr_in_range;
195 } else {
196 LLDB_LOG_ERROR(GetLog(DWARFLog::DebugInfo), ranges.takeError(),
197 "DIE({1:x}): {0}", GetID());
198 }
199 }
200
201 if (check_children) {
202 for (DWARFDIE child : children()) {
203 if (DWARFDIE child_result = child.LookupDeepestBlock(address))
204 return child_result;
205 }
206 }
207 return result;
208}
209
210const char *DWARFDIE::GetMangledName(bool substitute_name_allowed) const {
211 if (IsValid())
212 return m_die->GetMangledName(m_cu, substitute_name_allowed);
213 else
214 return nullptr;
215}
216
217const char *DWARFDIE::GetPubname() const {
218 if (IsValid())
219 return m_die->GetPubname(m_cu);
220 else
221 return nullptr;
222}
223
224// GetName
225//
226// Get value of the DW_AT_name attribute and place that value into the supplied
227// stream object. If the DIE is a NULL object "NULL" is placed into the stream,
228// and if no DW_AT_name attribute exists for the DIE then nothing is printed.
229void DWARFDIE::GetName(Stream &s) const {
230 if (!IsValid())
231 return;
232 if (GetDIE()->IsNULL()) {
233 s.PutCString("NULL");
234 return;
235 }
236 const char *name = GetDIE()->GetAttributeValueAsString(GetCU(), DW_AT_name, nullptr, true);
237 if (!name)
238 return;
239 s.PutCString(name);
240}
241
242// AppendTypeName
243//
244// Follows the type name definition down through all needed tags to end up with
245// a fully qualified type name and dump the results to the supplied stream.
246// This is used to show the name of types given a type identifier.
248 if (!IsValid())
249 return;
250 if (GetDIE()->IsNULL()) {
251 s.PutCString("NULL");
252 return;
253 }
254 if (const char *name = GetPubname()) {
255 s.PutCString(name);
256 return;
257 }
258 switch (Tag()) {
259 case DW_TAG_array_type:
260 break; // print out a "[]" after printing the full type of the element
261 // below
262 case DW_TAG_base_type:
263 s.PutCString("base ");
264 break;
265 case DW_TAG_class_type:
266 s.PutCString("class ");
267 break;
268 case DW_TAG_const_type:
269 s.PutCString("const ");
270 break;
271 case DW_TAG_enumeration_type:
272 s.PutCString("enum ");
273 break;
274 case DW_TAG_file_type:
275 s.PutCString("file ");
276 break;
277 case DW_TAG_interface_type:
278 s.PutCString("interface ");
279 break;
280 case DW_TAG_packed_type:
281 s.PutCString("packed ");
282 break;
283 case DW_TAG_pointer_type:
284 break; // print out a '*' after printing the full type below
285 case DW_TAG_ptr_to_member_type:
286 break; // print out a '*' after printing the full type below
287 case DW_TAG_reference_type:
288 break; // print out a '&' after printing the full type below
289 case DW_TAG_restrict_type:
290 s.PutCString("restrict ");
291 break;
292 case DW_TAG_set_type:
293 s.PutCString("set ");
294 break;
295 case DW_TAG_shared_type:
296 s.PutCString("shared ");
297 break;
298 case DW_TAG_string_type:
299 s.PutCString("string ");
300 break;
301 case DW_TAG_structure_type:
302 s.PutCString("struct ");
303 break;
304 case DW_TAG_subrange_type:
305 s.PutCString("subrange ");
306 break;
307 case DW_TAG_subroutine_type:
308 s.PutCString("function ");
309 break;
310 case DW_TAG_thrown_type:
311 s.PutCString("thrown ");
312 break;
313 case DW_TAG_union_type:
314 s.PutCString("union ");
315 break;
316 case DW_TAG_unspecified_type:
317 s.PutCString("unspecified ");
318 break;
319 case DW_TAG_volatile_type:
320 s.PutCString("volatile ");
321 break;
322 case DW_TAG_LLVM_ptrauth_type: {
323 unsigned key = GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_key, 0);
324 bool isAddressDiscriminated = GetAttributeValueAsUnsigned(
325 DW_AT_LLVM_ptrauth_address_discriminated, 0);
326 unsigned extraDiscriminator =
327 GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_extra_discriminator, 0);
328 bool isaPointer =
329 GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_isa_pointer, 0);
330 bool authenticatesNullValues = GetAttributeValueAsUnsigned(
331 DW_AT_LLVM_ptrauth_authenticates_null_values, 0);
332 unsigned authenticationMode =
333 GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_authentication_mode, 3);
334
335 s.Printf("__ptrauth(%d, %d, 0x0%x, %d, %d, %d)", key,
336 isAddressDiscriminated, extraDiscriminator, isaPointer,
337 authenticatesNullValues, authenticationMode);
338 break;
339 }
340 default:
341 return;
342 }
343
344 // Follow the DW_AT_type if possible
345 if (DWARFDIE next_die = GetAttributeValueAsReferenceDIE(DW_AT_type))
346 next_die.AppendTypeName(s);
347
348 switch (Tag()) {
349 case DW_TAG_array_type:
350 s.PutCString("[]");
351 break;
352 case DW_TAG_pointer_type:
353 s.PutChar('*');
354 break;
355 case DW_TAG_ptr_to_member_type:
356 s.PutChar('*');
357 break;
358 case DW_TAG_reference_type:
359 s.PutChar('&');
360 break;
361 default:
362 break;
363 }
364}
365
367 if (IsValid())
368 return GetDWARF()->ResolveType(*this, true);
369 else
370 return nullptr;
371}
372
375 return dwarf->ResolveTypeUID(die, true);
376 return nullptr;
377}
378
380 llvm::SmallSet<lldb::user_id_t, 4> &seen,
381 std::vector<CompilerContext> &context) {
382 // Stop if we hit a cycle.
383 while (die && seen.insert(die.GetID()).second) {
384 // Handle outline member function DIEs by following the specification.
385 if (DWARFDIE spec = die.GetReferencedDIE(DW_AT_specification)) {
386 die = spec;
387 continue;
388 }
389
390 // Add this DIE's contribution at the end of the chain.
391 auto push_ctx = [&](CompilerContextKind kind, llvm::StringRef name) {
392 context.push_back({kind, ConstString(name)});
393 };
394 switch (die.Tag()) {
395 case DW_TAG_module:
396 push_ctx(CompilerContextKind::Module, die.GetName());
397 break;
398 case DW_TAG_namespace:
400 break;
401 case DW_TAG_class_type:
402 case DW_TAG_structure_type:
404 break;
405 case DW_TAG_union_type:
406 push_ctx(CompilerContextKind::Union, die.GetName());
407 break;
408 case DW_TAG_enumeration_type:
409 push_ctx(CompilerContextKind::Enum, die.GetName());
410 break;
411 case DW_TAG_subprogram:
412 push_ctx(CompilerContextKind::Function, die.GetName());
413 break;
414 case DW_TAG_variable:
416 break;
417 case DW_TAG_typedef:
418 push_ctx(CompilerContextKind::Typedef, die.GetName());
419 break;
420 default:
421 break;
422 }
423 // Now process the parent.
424 die = die.GetParent();
425 }
426}
427
428std::vector<CompilerContext> DWARFDIE::GetDeclContext() const {
429 llvm::SmallSet<lldb::user_id_t, 4> seen;
430 std::vector<CompilerContext> context;
431 GetDeclContextImpl(*this, seen, context);
432 std::reverse(context.begin(), context.end());
433 return context;
434}
435
437 llvm::SmallSet<lldb::user_id_t, 4> &seen,
438 std::vector<CompilerContext> &context) {
439 // Stop if we hit a cycle.
440 while (die && seen.insert(die.GetID()).second) {
441 // Add this DIE's contribution at the end of the chain.
442 auto push_ctx = [&](CompilerContextKind kind, llvm::StringRef name) {
443 context.push_back({kind, ConstString(name)});
444 };
445 switch (die.Tag()) {
446 case DW_TAG_namespace:
448 break;
449 case DW_TAG_class_type:
450 case DW_TAG_structure_type:
452 break;
453 case DW_TAG_union_type:
454 push_ctx(CompilerContextKind::Union, die.GetName());
455 break;
456 case DW_TAG_enumeration_type:
457 push_ctx(CompilerContextKind::Enum, die.GetName());
458 break;
459 case DW_TAG_variable:
461 break;
462 case DW_TAG_typedef:
463 push_ctx(CompilerContextKind::Typedef, die.GetName());
464 break;
465 case DW_TAG_base_type:
466 push_ctx(CompilerContextKind::Builtin, die.GetName());
467 break;
468 // If any of the tags below appear in the parent chain, stop the decl
469 // context and return. Prior to these being in here, if a type existed in a
470 // namespace "a" like "a::my_struct", but we also have a function in that
471 // same namespace "a" which contained a type named "my_struct", both would
472 // return "a::my_struct" as the declaration context since the
473 // DW_TAG_subprogram would be skipped and its parent would be found.
474 case DW_TAG_compile_unit:
475 case DW_TAG_type_unit:
476 case DW_TAG_subprogram:
477 case DW_TAG_lexical_block:
478 case DW_TAG_inlined_subroutine:
479 return;
480 default:
481 break;
482 }
483 // Now process the parent.
484 die = die.GetParent();
485 }
486}
487
488std::vector<CompilerContext> DWARFDIE::GetTypeLookupContext() const {
489 llvm::SmallSet<lldb::user_id_t, 4> seen;
490 std::vector<CompilerContext> context;
491 GetTypeLookupContextImpl(*this, seen, context);
492 std::reverse(context.begin(), context.end());
493 return context;
494}
495
497 DWARFDeclContext dwarf_decl_ctx;
498 while (die) {
499 const dw_tag_t tag = die.Tag();
500 if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
501 break;
502 dwarf_decl_ctx.AppendDeclContext(tag, die.GetName());
503 DWARFDIE parent_decl_ctx_die = die.GetParentDeclContextDIE();
504 if (parent_decl_ctx_die == die)
505 break;
506 die = parent_decl_ctx_die;
507 }
508 return dwarf_decl_ctx;
509}
510
512 return GetDWARFDeclContextImpl(*this);
513}
514
516 DWARFDIE orig_die = die;
517 while (die) {
518 // If this is the original DIE that we are searching for a declaration for,
519 // then don't look in the cache as we don't want our own decl context to be
520 // our decl context...
521 if (die != orig_die) {
522 switch (die.Tag()) {
523 case DW_TAG_compile_unit:
524 case DW_TAG_partial_unit:
525 case DW_TAG_namespace:
526 case DW_TAG_structure_type:
527 case DW_TAG_union_type:
528 case DW_TAG_class_type:
529 return die;
530
531 default:
532 break;
533 }
534 }
535
536 if (DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification)) {
537 if (DWARFDIE decl_ctx_die = spec_die.GetParentDeclContextDIE())
538 return decl_ctx_die;
539 }
540
541 if (DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin)) {
542 if (DWARFDIE decl_ctx_die = abs_die.GetParentDeclContextDIE())
543 return decl_ctx_die;
544 }
545
546 die = die.GetParent();
547 }
548 return DWARFDIE();
549}
550
553 return GetParentDeclContextDIEImpl(*this);
554}
555
557 const dw_tag_t tag = Tag();
558 return tag == DW_TAG_class_type || tag == DW_TAG_structure_type ||
559 tag == DW_TAG_union_type;
560}
561
562bool DWARFDIE::IsMethod() const {
563 for (DWARFDIE d : elaborating_dies(*this))
564 if (d.GetParent().IsStructUnionOrClass())
565 return true;
566 return false;
567}
568
570 const char *&name, const char *&mangled,
571 llvm::DWARFAddressRangesVector &ranges, std::optional<int> &decl_file,
572 std::optional<int> &decl_line, std::optional<int> &decl_column,
573 std::optional<int> &call_file, std::optional<int> &call_line,
574 std::optional<int> &call_column,
575 lldb_private::DWARFExpressionList *frame_base) const {
576 if (IsValid()) {
578 GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column,
579 call_file, call_line, call_column, frame_base);
580 } else
581 return false;
582}
583
584// The following methods use LLVM naming convension in order to be are used by
585// LLVM libraries.
586llvm::iterator_range<DWARFDIE::child_iterator> DWARFDIE::children() const {
587 return llvm::make_range(child_iterator(*this), child_iterator());
588}
589
591 return child_iterator(*this);
592}
593
595
596std::optional<DWARFFormValue> DWARFDIE::find(const dw_attr_t attr) const {
597 DWARFFormValue form_value;
598 if (m_die->GetAttributeValue(m_cu, attr, form_value, nullptr, false))
599 return form_value;
600 return std::nullopt;
601}
602
603std::optional<uint64_t> DWARFDIE::getLanguage() const {
604 if (IsValid())
605 return m_cu->GetDWARFLanguageType();
606 return std::nullopt;
607}
608
610 return GetReferencedDIE(attr);
611}
612
614 if (IsValid())
615 return v.Reference();
616 return {};
617}
618
620 if (DWARFDIE reference = GetReferencedDIE(DW_AT_signature))
621 return reference;
622 return *this;
623}
static void GetTypeLookupContextImpl(DWARFDIE die, llvm::SmallSet< lldb::user_id_t, 4 > &seen, std::vector< CompilerContext > &context)
Definition: DWARFDIE.cpp:436
static DWARFDeclContext GetDWARFDeclContextImpl(DWARFDIE die)
Definition: DWARFDIE.cpp:496
static void GetDeclContextImpl(DWARFDIE die, llvm::SmallSet< lldb::user_id_t, 4 > &seen, std::vector< CompilerContext > &context)
Definition: DWARFDIE.cpp:379
static DWARFDIE GetParentDeclContextDIEImpl(DWARFDIE die)
Definition: DWARFDIE.cpp:515
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:392
A uniqued constant string class.
Definition: ConstString.h:40
"lldb/Expression/DWARFExpressionList.h" Encapsulates a range map from file address range to a single ...
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:65
size_t PutChar(char ch)
Definition: Stream.cpp:131
uint64_t GetAttributeValueAsUnsigned(const dw_attr_t attr, uint64_t fail_value) const
const char * GetMangledName(bool substitute_name_allowed=true) const
Definition: DWARFDIE.cpp:210
DWARFDIE resolveTypeUnitReference() const
Definition: DWARFDIE.cpp:619
bool GetDIENamesAndRanges(const char *&name, const char *&mangled, llvm::DWARFAddressRangesVector &ranges, 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
Definition: DWARFDIE.cpp:569
DWARFDIE resolveReferencedType(dw_attr_t attr) const
Definition: DWARFDIE.cpp:609
std::vector< CompilerContext > GetDeclContext() const
Return this DIE's decl context as it is needed to look up types in Clang modules.
Definition: DWARFDIE.cpp:428
DWARFDIE GetDIE(dw_offset_t die_offset) const
Definition: DWARFDIE.cpp:124
llvm::iterator_range< child_iterator > children() const
The range of all the children of this DIE.
Definition: DWARFDIE.cpp:586
DWARFDIE GetParentDeclContextDIE() const
Definition: DWARFDIE.cpp:552
Type * ResolveTypeUID(const DWARFDIE &die) const
Definition: DWARFDIE.cpp:373
DWARFDIE LookupDeepestBlock(lldb::addr_t file_addr) const
Definition: DWARFDIE.cpp:145
std::optional< DWARFFormValue > find(const dw_attr_t attr) const
Definition: DWARFDIE.cpp:596
DWARFDIE GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const
Definition: DWARFDIE.cpp:132
DWARFDebugInfoEntry * GetDIE() const
Definition: DWARFBaseDIE.h:61
DWARFDeclContext GetDWARFDeclContext() const
Definition: DWARFDIE.cpp:511
std::optional< uint64_t > getLanguage() const
Definition: DWARFDIE.cpp:603
void AppendTypeName(Stream &s) const
Definition: DWARFDIE.cpp:247
child_iterator begin() const
Definition: DWARFDIE.cpp:590
DWARFDIE GetReferencedDIE(const dw_attr_t attr) const
Definition: DWARFDIE.cpp:116
std::vector< CompilerContext > GetTypeLookupContext() const
Get a context to a type so it can be looked up.
Definition: DWARFDIE.cpp:488
llvm::Expected< llvm::DWARFAddressRangesVector > GetAttributeAddressRanges(DWARFUnit *cu, bool check_hi_lo_pc, bool check_elaborating_dies=false) const
const char * GetMangledName(const DWARFUnit *cu, bool substitute_name_allowed=true) const
DWARFDIE GetAttributeValueAsReference(const DWARFUnit *cu, const dw_attr_t attr, bool check_elaborating_dies=false) const
const char * GetAttributeValueAsString(const DWARFUnit *cu, const dw_attr_t attr, const char *fail_value, bool check_elaborating_dies=false) const
bool GetDIENamesAndRanges(DWARFUnit *cu, const char *&name, const char *&mangled, llvm::DWARFAddressRangesVector &rangeList, 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=nullptr) const
const char * GetPubname(const DWARFUnit *cu) const
dw_offset_t GetAttributeValue(const DWARFUnit *cu, const dw_attr_t attr, DWARFFormValue &formValue, dw_offset_t *end_attr_offset_ptr=nullptr, bool check_elaborating_dies=false) const
void AppendDeclContext(dw_tag_t tag, const char *name)
DWARFDIE GetDIE(dw_offset_t die_offset)
Definition: DWARFUnit.cpp:654
Type * ResolveType(const DWARFDIE &die, bool assert_not_being_parsed=true, bool resolve_function_context=false)
uint64_t dw_offset_t
Definition: dwarf.h:30
llvm::dwarf::Tag dw_tag_t
Definition: dwarf.h:25
llvm::dwarf::Attribute dw_attr_t
Definition: dwarf.h:23
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:332
const Scalar operator*(Scalar lhs, Scalar rhs)
Definition: Scalar.cpp:557
bool operator==(const Address &lhs, const Address &rhs)
Definition: Address.cpp:1023
uint64_t addr_t
Definition: lldb-types.h:80