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 #include "llvm/ADT/iterator.h" 18 19 using namespace lldb_private; 20 using namespace lldb_private::dwarf; 21 using namespace lldb_private::plugin::dwarf; 22 23 namespace { 24 25 /// Iterate through all DIEs elaborating (i.e. reachable by a chain of 26 /// DW_AT_specification and DW_AT_abstract_origin attributes) a given DIE. For 27 /// convenience, the starting die is included in the sequence as the first 28 /// item. 29 class ElaboratingDIEIterator 30 : public llvm::iterator_facade_base< 31 ElaboratingDIEIterator, std::input_iterator_tag, DWARFDIE, 32 std::ptrdiff_t, DWARFDIE *, DWARFDIE *> { 33 34 // The operating invariant is: top of m_worklist contains the "current" item 35 // and the rest of the list are items yet to be visited. An empty worklist 36 // means we've reached the end. 37 // Infinite recursion is prevented by maintaining a list of seen DIEs. 38 // Container sizes are optimized for the case of following DW_AT_specification 39 // and DW_AT_abstract_origin just once. 40 llvm::SmallVector<DWARFDIE, 2> m_worklist; 41 llvm::SmallSet<DWARFDebugInfoEntry *, 3> m_seen; 42 43 void Next() { 44 assert(!m_worklist.empty() && "Incrementing end iterator?"); 45 46 // Pop the current item from the list. 47 DWARFDIE die = m_worklist.back(); 48 m_worklist.pop_back(); 49 50 // And add back any items that elaborate it. 51 for (dw_attr_t attr : {DW_AT_specification, DW_AT_abstract_origin}) { 52 if (DWARFDIE d = die.GetReferencedDIE(attr)) 53 if (m_seen.insert(die.GetDIE()).second) 54 m_worklist.push_back(d); 55 } 56 } 57 58 public: 59 /// An iterator starting at die d. 60 explicit ElaboratingDIEIterator(DWARFDIE d) : m_worklist(1, d) {} 61 62 /// End marker 63 ElaboratingDIEIterator() = default; 64 65 const DWARFDIE &operator*() const { return m_worklist.back(); } 66 ElaboratingDIEIterator &operator++() { 67 Next(); 68 return *this; 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 }; 78 79 llvm::iterator_range<ElaboratingDIEIterator> 80 elaborating_dies(const DWARFDIE &die) { 81 return llvm::make_range(ElaboratingDIEIterator(die), 82 ElaboratingDIEIterator()); 83 } 84 } // namespace 85 86 DWARFDIE 87 DWARFDIE::GetParent() const { 88 if (IsValid()) 89 return DWARFDIE(m_cu, m_die->GetParent()); 90 else 91 return DWARFDIE(); 92 } 93 94 DWARFDIE 95 DWARFDIE::GetFirstChild() const { 96 if (IsValid()) 97 return DWARFDIE(m_cu, m_die->GetFirstChild()); 98 else 99 return DWARFDIE(); 100 } 101 102 DWARFDIE 103 DWARFDIE::GetSibling() const { 104 if (IsValid()) 105 return DWARFDIE(m_cu, m_die->GetSibling()); 106 else 107 return DWARFDIE(); 108 } 109 110 DWARFDIE 111 DWARFDIE::GetReferencedDIE(const dw_attr_t attr) const { 112 if (IsValid()) 113 return m_die->GetAttributeValueAsReference(GetCU(), attr); 114 else 115 return {}; 116 } 117 118 DWARFDIE 119 DWARFDIE::GetDIE(dw_offset_t die_offset) const { 120 if (IsValid()) 121 return m_cu->GetDIE(die_offset); 122 else 123 return DWARFDIE(); 124 } 125 126 DWARFDIE 127 DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const { 128 if (IsValid()) { 129 DWARFUnit *cu = GetCU(); 130 const bool check_specification_or_abstract_origin = true; 131 DWARFFormValue form_value; 132 if (m_die->GetAttributeValue(cu, attr, form_value, nullptr, 133 check_specification_or_abstract_origin)) 134 return form_value.Reference(); 135 } 136 return DWARFDIE(); 137 } 138 139 DWARFDIE 140 DWARFDIE::LookupDeepestBlock(lldb::addr_t address) const { 141 if (!IsValid()) 142 return DWARFDIE(); 143 144 DWARFDIE result; 145 bool check_children = false; 146 bool match_addr_range = false; 147 switch (Tag()) { 148 case DW_TAG_class_type: 149 case DW_TAG_namespace: 150 case DW_TAG_structure_type: 151 case DW_TAG_common_block: 152 check_children = true; 153 break; 154 case DW_TAG_compile_unit: 155 case DW_TAG_module: 156 case DW_TAG_catch_block: 157 case DW_TAG_subprogram: 158 case DW_TAG_try_block: 159 case DW_TAG_partial_unit: 160 match_addr_range = true; 161 break; 162 case DW_TAG_lexical_block: 163 case DW_TAG_inlined_subroutine: 164 check_children = true; 165 match_addr_range = true; 166 break; 167 default: 168 break; 169 } 170 171 if (match_addr_range) { 172 DWARFRangeList ranges = 173 m_die->GetAttributeAddressRanges(m_cu, /*check_hi_lo_pc=*/true); 174 if (ranges.FindEntryThatContains(address)) { 175 check_children = true; 176 switch (Tag()) { 177 default: 178 break; 179 180 case DW_TAG_inlined_subroutine: // Inlined Function 181 case DW_TAG_lexical_block: // Block { } in code 182 result = *this; 183 break; 184 } 185 } else { 186 check_children = false; 187 } 188 } 189 190 if (check_children) { 191 for (DWARFDIE child : children()) { 192 if (DWARFDIE child_result = child.LookupDeepestBlock(address)) 193 return child_result; 194 } 195 } 196 return result; 197 } 198 199 const char *DWARFDIE::GetMangledName() const { 200 if (IsValid()) 201 return m_die->GetMangledName(m_cu); 202 else 203 return nullptr; 204 } 205 206 const char *DWARFDIE::GetPubname() const { 207 if (IsValid()) 208 return m_die->GetPubname(m_cu); 209 else 210 return nullptr; 211 } 212 213 // GetName 214 // 215 // Get value of the DW_AT_name attribute and place that value into the supplied 216 // stream object. If the DIE is a NULL object "NULL" is placed into the stream, 217 // and if no DW_AT_name attribute exists for the DIE then nothing is printed. 218 void DWARFDIE::GetName(Stream &s) const { 219 if (!IsValid()) 220 return; 221 if (GetDIE()->IsNULL()) { 222 s.PutCString("NULL"); 223 return; 224 } 225 const char *name = GetDIE()->GetAttributeValueAsString(GetCU(), DW_AT_name, nullptr, true); 226 if (!name) 227 return; 228 s.PutCString(name); 229 } 230 231 // AppendTypeName 232 // 233 // Follows the type name definition down through all needed tags to end up with 234 // a fully qualified type name and dump the results to the supplied stream. 235 // This is used to show the name of types given a type identifier. 236 void DWARFDIE::AppendTypeName(Stream &s) const { 237 if (!IsValid()) 238 return; 239 if (GetDIE()->IsNULL()) { 240 s.PutCString("NULL"); 241 return; 242 } 243 if (const char *name = GetPubname()) { 244 s.PutCString(name); 245 return; 246 } 247 switch (Tag()) { 248 case DW_TAG_array_type: 249 break; // print out a "[]" after printing the full type of the element 250 // below 251 case DW_TAG_base_type: 252 s.PutCString("base "); 253 break; 254 case DW_TAG_class_type: 255 s.PutCString("class "); 256 break; 257 case DW_TAG_const_type: 258 s.PutCString("const "); 259 break; 260 case DW_TAG_enumeration_type: 261 s.PutCString("enum "); 262 break; 263 case DW_TAG_file_type: 264 s.PutCString("file "); 265 break; 266 case DW_TAG_interface_type: 267 s.PutCString("interface "); 268 break; 269 case DW_TAG_packed_type: 270 s.PutCString("packed "); 271 break; 272 case DW_TAG_pointer_type: 273 break; // print out a '*' after printing the full type below 274 case DW_TAG_ptr_to_member_type: 275 break; // print out a '*' after printing the full type below 276 case DW_TAG_reference_type: 277 break; // print out a '&' after printing the full type below 278 case DW_TAG_restrict_type: 279 s.PutCString("restrict "); 280 break; 281 case DW_TAG_set_type: 282 s.PutCString("set "); 283 break; 284 case DW_TAG_shared_type: 285 s.PutCString("shared "); 286 break; 287 case DW_TAG_string_type: 288 s.PutCString("string "); 289 break; 290 case DW_TAG_structure_type: 291 s.PutCString("struct "); 292 break; 293 case DW_TAG_subrange_type: 294 s.PutCString("subrange "); 295 break; 296 case DW_TAG_subroutine_type: 297 s.PutCString("function "); 298 break; 299 case DW_TAG_thrown_type: 300 s.PutCString("thrown "); 301 break; 302 case DW_TAG_union_type: 303 s.PutCString("union "); 304 break; 305 case DW_TAG_unspecified_type: 306 s.PutCString("unspecified "); 307 break; 308 case DW_TAG_volatile_type: 309 s.PutCString("volatile "); 310 break; 311 case DW_TAG_LLVM_ptrauth_type: { 312 unsigned key = GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_key, 0); 313 bool isAddressDiscriminated = GetAttributeValueAsUnsigned( 314 DW_AT_LLVM_ptrauth_address_discriminated, 0); 315 unsigned extraDiscriminator = 316 GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_extra_discriminator, 0); 317 bool isaPointer = 318 GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_isa_pointer, 0); 319 s.Printf("__ptrauth(%d, %d, 0x0%x, %d)", key, isAddressDiscriminated, 320 extraDiscriminator, isaPointer); 321 break; 322 } 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 std::vector<lldb_private::CompilerContext> DWARFDIE::GetDeclContext() const { 377 std::vector<lldb_private::CompilerContext> context; 378 const dw_tag_t tag = Tag(); 379 if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit) 380 return context; 381 DWARFDIE parent = GetParent(); 382 if (parent) 383 context = parent.GetDeclContext(); 384 auto push_ctx = [&](CompilerContextKind kind, llvm::StringRef name) { 385 context.push_back({kind, ConstString(name)}); 386 }; 387 switch (tag) { 388 case DW_TAG_module: 389 push_ctx(CompilerContextKind::Module, GetName()); 390 break; 391 case DW_TAG_namespace: 392 push_ctx(CompilerContextKind::Namespace, GetName()); 393 break; 394 case DW_TAG_structure_type: 395 push_ctx(CompilerContextKind::Struct, GetName()); 396 break; 397 case DW_TAG_union_type: 398 push_ctx(CompilerContextKind::Union, GetName()); 399 break; 400 case DW_TAG_class_type: 401 push_ctx(CompilerContextKind::Class, GetName()); 402 break; 403 case DW_TAG_enumeration_type: 404 push_ctx(CompilerContextKind::Enum, GetName()); 405 break; 406 case DW_TAG_subprogram: 407 push_ctx(CompilerContextKind::Function, GetPubname()); 408 break; 409 case DW_TAG_variable: 410 push_ctx(CompilerContextKind::Variable, GetPubname()); 411 break; 412 case DW_TAG_typedef: 413 push_ctx(CompilerContextKind::Typedef, GetName()); 414 break; 415 default: 416 break; 417 } 418 return context; 419 } 420 421 std::vector<lldb_private::CompilerContext> 422 DWARFDIE::GetTypeLookupContext() const { 423 std::vector<lldb_private::CompilerContext> context; 424 // If there is no name, then there is no need to look anything up for this 425 // DIE. 426 const char *name = GetName(); 427 if (!name || !name[0]) 428 return context; 429 const dw_tag_t tag = Tag(); 430 if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit) 431 return context; 432 DWARFDIE parent = GetParent(); 433 if (parent) 434 context = parent.GetTypeLookupContext(); 435 auto push_ctx = [&](CompilerContextKind kind, llvm::StringRef name) { 436 context.push_back({kind, ConstString(name)}); 437 }; 438 switch (tag) { 439 case DW_TAG_namespace: 440 push_ctx(CompilerContextKind::Namespace, name); 441 break; 442 case DW_TAG_structure_type: 443 push_ctx(CompilerContextKind::Struct, name); 444 break; 445 case DW_TAG_union_type: 446 push_ctx(CompilerContextKind::Union, name); 447 break; 448 case DW_TAG_class_type: 449 push_ctx(CompilerContextKind::Class, name); 450 break; 451 case DW_TAG_enumeration_type: 452 push_ctx(CompilerContextKind::Enum, name); 453 break; 454 case DW_TAG_variable: 455 push_ctx(CompilerContextKind::Variable, GetPubname()); 456 break; 457 case DW_TAG_typedef: 458 push_ctx(CompilerContextKind::Typedef, name); 459 break; 460 case DW_TAG_base_type: 461 push_ctx(CompilerContextKind::Builtin, name); 462 break; 463 default: 464 break; 465 } 466 return context; 467 } 468 469 DWARFDIE 470 DWARFDIE::GetParentDeclContextDIE() const { 471 if (IsValid()) 472 return m_die->GetParentDeclContextDIE(m_cu); 473 else 474 return DWARFDIE(); 475 } 476 477 bool DWARFDIE::IsStructUnionOrClass() const { 478 const dw_tag_t tag = Tag(); 479 return tag == DW_TAG_class_type || tag == DW_TAG_structure_type || 480 tag == DW_TAG_union_type; 481 } 482 483 bool DWARFDIE::IsMethod() const { 484 for (DWARFDIE d : elaborating_dies(*this)) 485 if (d.GetParent().IsStructUnionOrClass()) 486 return true; 487 return false; 488 } 489 490 bool DWARFDIE::GetDIENamesAndRanges( 491 const char *&name, const char *&mangled, DWARFRangeList &ranges, 492 std::optional<int> &decl_file, std::optional<int> &decl_line, 493 std::optional<int> &decl_column, std::optional<int> &call_file, 494 std::optional<int> &call_line, std::optional<int> &call_column, 495 lldb_private::DWARFExpressionList *frame_base) const { 496 if (IsValid()) { 497 return m_die->GetDIENamesAndRanges( 498 GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column, 499 call_file, call_line, call_column, frame_base); 500 } else 501 return false; 502 } 503 504 llvm::iterator_range<DWARFDIE::child_iterator> DWARFDIE::children() const { 505 return llvm::make_range(child_iterator(*this), child_iterator()); 506 } 507