1 //===-- Address.cpp ---------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/Core/Address.h" 11 12 #include "lldb/Core/ArchSpec.h" // for ArchSpec 13 #include "lldb/Core/DumpDataExtractor.h" 14 #include "lldb/Core/Module.h" 15 #include "lldb/Core/ModuleList.h" // for ModuleList 16 #include "lldb/Core/Section.h" 17 #include "lldb/Symbol/Block.h" 18 #include "lldb/Symbol/Declaration.h" // for Declaration 19 #include "lldb/Symbol/LineEntry.h" // for LineEntry 20 #include "lldb/Symbol/ObjectFile.h" 21 #include "lldb/Symbol/Symbol.h" // for Symbol 22 #include "lldb/Symbol/SymbolContext.h" // for SymbolContext 23 #include "lldb/Symbol/SymbolVendor.h" 24 #include "lldb/Symbol/Symtab.h" // for Symtab 25 #include "lldb/Symbol/Type.h" // for Type 26 #include "lldb/Symbol/Variable.h" 27 #include "lldb/Symbol/VariableList.h" 28 #include "lldb/Target/ExecutionContext.h" 29 #include "lldb/Target/ExecutionContextScope.h" // for ExecutionContextScope 30 #include "lldb/Target/Process.h" 31 #include "lldb/Target/SectionLoadList.h" 32 #include "lldb/Target/Target.h" 33 #include "lldb/Utility/ConstString.h" // for ConstString 34 #include "lldb/Utility/DataExtractor.h" // for DataExtractor 35 #include "lldb/Utility/Endian.h" // for InlHostByteOrder 36 #include "lldb/Utility/FileSpec.h" // for FileSpec 37 #include "lldb/Utility/Status.h" // for Status 38 #include "lldb/Utility/Stream.h" // for Stream 39 #include "lldb/Utility/StreamString.h" // for StreamString 40 41 #include "llvm/ADT/StringRef.h" // for StringRef 42 #include "llvm/ADT/Triple.h" 43 #include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH 44 45 #include <cstdint> // for uint8_t, uint32_t 46 #include <memory> // for shared_ptr, operator!= 47 #include <vector> // for vector 48 49 #include <assert.h> // for assert 50 #include <inttypes.h> // for PRIu64, PRIx64 51 #include <string.h> // for size_t, strlen 52 53 namespace lldb_private { 54 class CompileUnit; 55 } 56 namespace lldb_private { 57 class Function; 58 } 59 60 using namespace lldb; 61 using namespace lldb_private; 62 63 static size_t ReadBytes(ExecutionContextScope *exe_scope, 64 const Address &address, void *dst, size_t dst_len) { 65 if (exe_scope == nullptr) 66 return 0; 67 68 TargetSP target_sp(exe_scope->CalculateTarget()); 69 if (target_sp) { 70 Status error; 71 bool prefer_file_cache = false; 72 return target_sp->ReadMemory(address, prefer_file_cache, dst, dst_len, 73 error); 74 } 75 return 0; 76 } 77 78 static bool GetByteOrderAndAddressSize(ExecutionContextScope *exe_scope, 79 const Address &address, 80 ByteOrder &byte_order, 81 uint32_t &addr_size) { 82 byte_order = eByteOrderInvalid; 83 addr_size = 0; 84 if (exe_scope == nullptr) 85 return false; 86 87 TargetSP target_sp(exe_scope->CalculateTarget()); 88 if (target_sp) { 89 byte_order = target_sp->GetArchitecture().GetByteOrder(); 90 addr_size = target_sp->GetArchitecture().GetAddressByteSize(); 91 } 92 93 if (byte_order == eByteOrderInvalid || addr_size == 0) { 94 ModuleSP module_sp(address.GetModule()); 95 if (module_sp) { 96 byte_order = module_sp->GetArchitecture().GetByteOrder(); 97 addr_size = module_sp->GetArchitecture().GetAddressByteSize(); 98 } 99 } 100 return byte_order != eByteOrderInvalid && addr_size != 0; 101 } 102 103 static uint64_t ReadUIntMax64(ExecutionContextScope *exe_scope, 104 const Address &address, uint32_t byte_size, 105 bool &success) { 106 uint64_t uval64 = 0; 107 if (exe_scope == nullptr || byte_size > sizeof(uint64_t)) { 108 success = false; 109 return 0; 110 } 111 uint64_t buf = 0; 112 113 success = ReadBytes(exe_scope, address, &buf, byte_size) == byte_size; 114 if (success) { 115 ByteOrder byte_order = eByteOrderInvalid; 116 uint32_t addr_size = 0; 117 if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) { 118 DataExtractor data(&buf, sizeof(buf), byte_order, addr_size); 119 lldb::offset_t offset = 0; 120 uval64 = data.GetU64(&offset); 121 } else 122 success = false; 123 } 124 return uval64; 125 } 126 127 static bool ReadAddress(ExecutionContextScope *exe_scope, 128 const Address &address, uint32_t pointer_size, 129 Address &deref_so_addr) { 130 if (exe_scope == nullptr) 131 return false; 132 133 bool success = false; 134 addr_t deref_addr = ReadUIntMax64(exe_scope, address, pointer_size, success); 135 if (success) { 136 ExecutionContext exe_ctx; 137 exe_scope->CalculateExecutionContext(exe_ctx); 138 // If we have any sections that are loaded, try and resolve using the 139 // section load list 140 Target *target = exe_ctx.GetTargetPtr(); 141 if (target && !target->GetSectionLoadList().IsEmpty()) { 142 if (target->GetSectionLoadList().ResolveLoadAddress(deref_addr, 143 deref_so_addr)) 144 return true; 145 } else { 146 // If we were not running, yet able to read an integer, we must 147 // have a module 148 ModuleSP module_sp(address.GetModule()); 149 150 assert(module_sp); 151 if (module_sp->ResolveFileAddress(deref_addr, deref_so_addr)) 152 return true; 153 } 154 155 // We couldn't make "deref_addr" into a section offset value, but we were 156 // able to read the address, so we return a section offset address with 157 // no section and "deref_addr" as the offset (address). 158 deref_so_addr.SetRawAddress(deref_addr); 159 return true; 160 } 161 return false; 162 } 163 164 static bool DumpUInt(ExecutionContextScope *exe_scope, const Address &address, 165 uint32_t byte_size, Stream *strm) { 166 if (exe_scope == nullptr || byte_size == 0) 167 return 0; 168 std::vector<uint8_t> buf(byte_size, 0); 169 170 if (ReadBytes(exe_scope, address, &buf[0], buf.size()) == buf.size()) { 171 ByteOrder byte_order = eByteOrderInvalid; 172 uint32_t addr_size = 0; 173 if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) { 174 DataExtractor data(&buf.front(), buf.size(), byte_order, addr_size); 175 176 DumpDataExtractor(data, strm, 177 0, // Start offset in "data" 178 eFormatHex, // Print as characters 179 buf.size(), // Size of item 180 1, // Items count 181 UINT32_MAX, // num per line 182 LLDB_INVALID_ADDRESS, // base address 183 0, // bitfield bit size 184 0); // bitfield bit offset 185 186 return true; 187 } 188 } 189 return false; 190 } 191 192 static size_t ReadCStringFromMemory(ExecutionContextScope *exe_scope, 193 const Address &address, Stream *strm) { 194 if (exe_scope == nullptr) 195 return 0; 196 const size_t k_buf_len = 256; 197 char buf[k_buf_len + 1]; 198 buf[k_buf_len] = '\0'; // NULL terminate 199 200 // Byte order and address size don't matter for C string dumping.. 201 DataExtractor data(buf, sizeof(buf), endian::InlHostByteOrder(), 4); 202 size_t total_len = 0; 203 size_t bytes_read; 204 Address curr_address(address); 205 strm->PutChar('"'); 206 while ((bytes_read = ReadBytes(exe_scope, curr_address, buf, k_buf_len)) > 207 0) { 208 size_t len = strlen(buf); 209 if (len == 0) 210 break; 211 if (len > bytes_read) 212 len = bytes_read; 213 214 DumpDataExtractor(data, strm, 215 0, // Start offset in "data" 216 eFormatChar, // Print as characters 217 1, // Size of item (1 byte for a char!) 218 len, // How many bytes to print? 219 UINT32_MAX, // num per line 220 LLDB_INVALID_ADDRESS, // base address 221 0, // bitfield bit size 222 223 0); // bitfield bit offset 224 225 total_len += bytes_read; 226 227 if (len < k_buf_len) 228 break; 229 curr_address.SetOffset(curr_address.GetOffset() + bytes_read); 230 } 231 strm->PutChar('"'); 232 return total_len; 233 } 234 235 Address::Address(lldb::addr_t abs_addr) : m_section_wp(), m_offset(abs_addr) {} 236 237 Address::Address(addr_t address, const SectionList *section_list) 238 : m_section_wp(), m_offset(LLDB_INVALID_ADDRESS) { 239 ResolveAddressUsingFileSections(address, section_list); 240 } 241 242 const Address &Address::operator=(const Address &rhs) { 243 if (this != &rhs) { 244 m_section_wp = rhs.m_section_wp; 245 m_offset = rhs.m_offset; 246 } 247 return *this; 248 } 249 250 bool Address::ResolveAddressUsingFileSections(addr_t file_addr, 251 const SectionList *section_list) { 252 if (section_list) { 253 SectionSP section_sp( 254 section_list->FindSectionContainingFileAddress(file_addr)); 255 m_section_wp = section_sp; 256 if (section_sp) { 257 assert(section_sp->ContainsFileAddress(file_addr)); 258 m_offset = file_addr - section_sp->GetFileAddress(); 259 return true; // Successfully transformed addr into a section offset 260 // address 261 } 262 } 263 m_offset = file_addr; 264 return false; // Failed to resolve this address to a section offset value 265 } 266 267 ModuleSP Address::GetModule() const { 268 lldb::ModuleSP module_sp; 269 SectionSP section_sp(GetSection()); 270 if (section_sp) 271 module_sp = section_sp->GetModule(); 272 return module_sp; 273 } 274 275 addr_t Address::GetFileAddress() const { 276 SectionSP section_sp(GetSection()); 277 if (section_sp) { 278 addr_t sect_file_addr = section_sp->GetFileAddress(); 279 if (sect_file_addr == LLDB_INVALID_ADDRESS) { 280 // Section isn't resolved, we can't return a valid file address 281 return LLDB_INVALID_ADDRESS; 282 } 283 // We have a valid file range, so we can return the file based 284 // address by adding the file base address to our offset 285 return sect_file_addr + m_offset; 286 } else if (SectionWasDeletedPrivate()) { 287 // Used to have a valid section but it got deleted so the 288 // offset doesn't mean anything without the section 289 return LLDB_INVALID_ADDRESS; 290 } 291 // No section, we just return the offset since it is the value in this case 292 return m_offset; 293 } 294 295 addr_t Address::GetLoadAddress(Target *target) const { 296 SectionSP section_sp(GetSection()); 297 if (section_sp) { 298 if (target) { 299 addr_t sect_load_addr = section_sp->GetLoadBaseAddress(target); 300 301 if (sect_load_addr != LLDB_INVALID_ADDRESS) { 302 // We have a valid file range, so we can return the file based 303 // address by adding the file base address to our offset 304 return sect_load_addr + m_offset; 305 } 306 } 307 } else if (SectionWasDeletedPrivate()) { 308 // Used to have a valid section but it got deleted so the 309 // offset doesn't mean anything without the section 310 return LLDB_INVALID_ADDRESS; 311 } else { 312 // We don't have a section so the offset is the load address 313 return m_offset; 314 } 315 // The section isn't resolved or an invalid target was passed in 316 // so we can't return a valid load address. 317 return LLDB_INVALID_ADDRESS; 318 } 319 320 addr_t Address::GetCallableLoadAddress(Target *target, bool is_indirect) const { 321 addr_t code_addr = LLDB_INVALID_ADDRESS; 322 323 if (is_indirect && target) { 324 ProcessSP processSP = target->GetProcessSP(); 325 Status error; 326 if (processSP) { 327 code_addr = processSP->ResolveIndirectFunction(this, error); 328 if (!error.Success()) 329 code_addr = LLDB_INVALID_ADDRESS; 330 } 331 } else { 332 code_addr = GetLoadAddress(target); 333 } 334 335 if (code_addr == LLDB_INVALID_ADDRESS) 336 return code_addr; 337 338 if (target) 339 return target->GetCallableLoadAddress(code_addr, GetAddressClass()); 340 return code_addr; 341 } 342 343 bool Address::SetCallableLoadAddress(lldb::addr_t load_addr, Target *target) { 344 if (SetLoadAddress(load_addr, target)) { 345 if (target) 346 m_offset = target->GetCallableLoadAddress(m_offset, GetAddressClass()); 347 return true; 348 } 349 return false; 350 } 351 352 addr_t Address::GetOpcodeLoadAddress(Target *target, 353 AddressClass addr_class) const { 354 addr_t code_addr = GetLoadAddress(target); 355 if (code_addr != LLDB_INVALID_ADDRESS) { 356 if (addr_class == eAddressClassInvalid) 357 addr_class = GetAddressClass(); 358 code_addr = target->GetOpcodeLoadAddress(code_addr, addr_class); 359 } 360 return code_addr; 361 } 362 363 bool Address::SetOpcodeLoadAddress(lldb::addr_t load_addr, Target *target, 364 AddressClass addr_class, 365 bool allow_section_end) { 366 if (SetLoadAddress(load_addr, target, allow_section_end)) { 367 if (target) { 368 if (addr_class == eAddressClassInvalid) 369 addr_class = GetAddressClass(); 370 m_offset = target->GetOpcodeLoadAddress(m_offset, addr_class); 371 } 372 return true; 373 } 374 return false; 375 } 376 377 bool Address::Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, 378 DumpStyle fallback_style, uint32_t addr_size) const { 379 // If the section was nullptr, only load address is going to work unless we 380 // are 381 // trying to deref a pointer 382 SectionSP section_sp(GetSection()); 383 if (!section_sp && style != DumpStyleResolvedPointerDescription) 384 style = DumpStyleLoadAddress; 385 386 ExecutionContext exe_ctx(exe_scope); 387 Target *target = exe_ctx.GetTargetPtr(); 388 // If addr_byte_size is UINT32_MAX, then determine the correct address 389 // byte size for the process or default to the size of addr_t 390 if (addr_size == UINT32_MAX) { 391 if (target) 392 addr_size = target->GetArchitecture().GetAddressByteSize(); 393 else 394 addr_size = sizeof(addr_t); 395 } 396 397 Address so_addr; 398 switch (style) { 399 case DumpStyleInvalid: 400 return false; 401 402 case DumpStyleSectionNameOffset: 403 if (section_sp) { 404 section_sp->DumpName(s); 405 s->Printf(" + %" PRIu64, m_offset); 406 } else { 407 s->Address(m_offset, addr_size); 408 } 409 break; 410 411 case DumpStyleSectionPointerOffset: 412 s->Printf("(Section *)%p + ", static_cast<void *>(section_sp.get())); 413 s->Address(m_offset, addr_size); 414 break; 415 416 case DumpStyleModuleWithFileAddress: 417 if (section_sp) { 418 ModuleSP module_sp = section_sp->GetModule(); 419 if (module_sp) 420 s->Printf("%s[", module_sp->GetFileSpec().GetFilename().AsCString( 421 "<Unknown>")); 422 else 423 s->Printf("%s[", "<Unknown>"); 424 } 425 LLVM_FALLTHROUGH; 426 case DumpStyleFileAddress: { 427 addr_t file_addr = GetFileAddress(); 428 if (file_addr == LLDB_INVALID_ADDRESS) { 429 if (fallback_style != DumpStyleInvalid) 430 return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size); 431 return false; 432 } 433 s->Address(file_addr, addr_size); 434 if (style == DumpStyleModuleWithFileAddress && section_sp) 435 s->PutChar(']'); 436 } break; 437 438 case DumpStyleLoadAddress: { 439 addr_t load_addr = GetLoadAddress(target); 440 441 /* 442 * MIPS: 443 * Display address in compressed form for MIPS16 or microMIPS 444 * if the address belongs to eAddressClassCodeAlternateISA. 445 */ 446 if (target) { 447 const llvm::Triple::ArchType llvm_arch = 448 target->GetArchitecture().GetMachine(); 449 if (llvm_arch == llvm::Triple::mips || 450 llvm_arch == llvm::Triple::mipsel || 451 llvm_arch == llvm::Triple::mips64 || 452 llvm_arch == llvm::Triple::mips64el) 453 load_addr = GetCallableLoadAddress(target); 454 } 455 456 if (load_addr == LLDB_INVALID_ADDRESS) { 457 if (fallback_style != DumpStyleInvalid) 458 return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size); 459 return false; 460 } 461 s->Address(load_addr, addr_size); 462 } break; 463 464 case DumpStyleResolvedDescription: 465 case DumpStyleResolvedDescriptionNoModule: 466 case DumpStyleResolvedDescriptionNoFunctionArguments: 467 case DumpStyleNoFunctionName: 468 if (IsSectionOffset()) { 469 uint32_t pointer_size = 4; 470 ModuleSP module_sp(GetModule()); 471 if (target) 472 pointer_size = target->GetArchitecture().GetAddressByteSize(); 473 else if (module_sp) 474 pointer_size = module_sp->GetArchitecture().GetAddressByteSize(); 475 476 bool showed_info = false; 477 if (section_sp) { 478 SectionType sect_type = section_sp->GetType(); 479 switch (sect_type) { 480 case eSectionTypeData: 481 if (module_sp) { 482 SymbolVendor *sym_vendor = module_sp->GetSymbolVendor(); 483 if (sym_vendor) { 484 Symtab *symtab = sym_vendor->GetSymtab(); 485 if (symtab) { 486 const addr_t file_Addr = GetFileAddress(); 487 Symbol *symbol = 488 symtab->FindSymbolContainingFileAddress(file_Addr); 489 if (symbol) { 490 const char *symbol_name = symbol->GetName().AsCString(); 491 if (symbol_name) { 492 s->PutCString(symbol_name); 493 addr_t delta = 494 file_Addr - symbol->GetAddressRef().GetFileAddress(); 495 if (delta) 496 s->Printf(" + %" PRIu64, delta); 497 showed_info = true; 498 } 499 } 500 } 501 } 502 } 503 break; 504 505 case eSectionTypeDataCString: 506 // Read the C string from memory and display it 507 showed_info = true; 508 ReadCStringFromMemory(exe_scope, *this, s); 509 break; 510 511 case eSectionTypeDataCStringPointers: 512 if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) { 513 #if VERBOSE_OUTPUT 514 s->PutCString("(char *)"); 515 so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, 516 DumpStyleFileAddress); 517 s->PutCString(": "); 518 #endif 519 showed_info = true; 520 ReadCStringFromMemory(exe_scope, so_addr, s); 521 } 522 break; 523 524 case eSectionTypeDataObjCMessageRefs: 525 if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) { 526 if (target && so_addr.IsSectionOffset()) { 527 SymbolContext func_sc; 528 target->GetImages().ResolveSymbolContextForAddress( 529 so_addr, eSymbolContextEverything, func_sc); 530 if (func_sc.function != nullptr || func_sc.symbol != nullptr) { 531 showed_info = true; 532 #if VERBOSE_OUTPUT 533 s->PutCString("(objc_msgref *) -> { (func*)"); 534 so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, 535 DumpStyleFileAddress); 536 #else 537 s->PutCString("{ "); 538 #endif 539 Address cstr_addr(*this); 540 cstr_addr.SetOffset(cstr_addr.GetOffset() + pointer_size); 541 func_sc.DumpStopContext(s, exe_scope, so_addr, true, true, 542 false, true, true); 543 if (ReadAddress(exe_scope, cstr_addr, pointer_size, so_addr)) { 544 #if VERBOSE_OUTPUT 545 s->PutCString("), (char *)"); 546 so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, 547 DumpStyleFileAddress); 548 s->PutCString(" ("); 549 #else 550 s->PutCString(", "); 551 #endif 552 ReadCStringFromMemory(exe_scope, so_addr, s); 553 } 554 #if VERBOSE_OUTPUT 555 s->PutCString(") }"); 556 #else 557 s->PutCString(" }"); 558 #endif 559 } 560 } 561 } 562 break; 563 564 case eSectionTypeDataObjCCFStrings: { 565 Address cfstring_data_addr(*this); 566 cfstring_data_addr.SetOffset(cfstring_data_addr.GetOffset() + 567 (2 * pointer_size)); 568 if (ReadAddress(exe_scope, cfstring_data_addr, pointer_size, 569 so_addr)) { 570 #if VERBOSE_OUTPUT 571 s->PutCString("(CFString *) "); 572 cfstring_data_addr.Dump(s, exe_scope, DumpStyleLoadAddress, 573 DumpStyleFileAddress); 574 s->PutCString(" -> @"); 575 #else 576 s->PutChar('@'); 577 #endif 578 if (so_addr.Dump(s, exe_scope, DumpStyleResolvedDescription)) 579 showed_info = true; 580 } 581 } break; 582 583 case eSectionTypeData4: 584 // Read the 4 byte data and display it 585 showed_info = true; 586 s->PutCString("(uint32_t) "); 587 DumpUInt(exe_scope, *this, 4, s); 588 break; 589 590 case eSectionTypeData8: 591 // Read the 8 byte data and display it 592 showed_info = true; 593 s->PutCString("(uint64_t) "); 594 DumpUInt(exe_scope, *this, 8, s); 595 break; 596 597 case eSectionTypeData16: 598 // Read the 16 byte data and display it 599 showed_info = true; 600 s->PutCString("(uint128_t) "); 601 DumpUInt(exe_scope, *this, 16, s); 602 break; 603 604 case eSectionTypeDataPointers: 605 // Read the pointer data and display it 606 if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) { 607 s->PutCString("(void *)"); 608 so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, 609 DumpStyleFileAddress); 610 611 showed_info = true; 612 if (so_addr.IsSectionOffset()) { 613 SymbolContext pointer_sc; 614 if (target) { 615 target->GetImages().ResolveSymbolContextForAddress( 616 so_addr, eSymbolContextEverything, pointer_sc); 617 if (pointer_sc.function != nullptr || 618 pointer_sc.symbol != nullptr) { 619 s->PutCString(": "); 620 pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false, 621 false, true, true); 622 } 623 } 624 } 625 } 626 break; 627 628 default: 629 break; 630 } 631 } 632 633 if (!showed_info) { 634 if (module_sp) { 635 SymbolContext sc; 636 module_sp->ResolveSymbolContextForAddress( 637 *this, eSymbolContextEverything, sc); 638 if (sc.function || sc.symbol) { 639 bool show_stop_context = true; 640 const bool show_module = (style == DumpStyleResolvedDescription); 641 const bool show_fullpaths = false; 642 const bool show_inlined_frames = true; 643 const bool show_function_arguments = 644 (style != DumpStyleResolvedDescriptionNoFunctionArguments); 645 const bool show_function_name = (style != DumpStyleNoFunctionName); 646 if (sc.function == nullptr && sc.symbol != nullptr) { 647 // If we have just a symbol make sure it is in the right section 648 if (sc.symbol->ValueIsAddress()) { 649 if (sc.symbol->GetAddressRef().GetSection() != GetSection()) { 650 // don't show the module if the symbol is a trampoline symbol 651 show_stop_context = false; 652 } 653 } 654 } 655 if (show_stop_context) { 656 // We have a function or a symbol from the same 657 // sections as this address. 658 sc.DumpStopContext(s, exe_scope, *this, show_fullpaths, 659 show_module, show_inlined_frames, 660 show_function_arguments, show_function_name); 661 } else { 662 // We found a symbol but it was in a different 663 // section so it isn't the symbol we should be 664 // showing, just show the section name + offset 665 Dump(s, exe_scope, DumpStyleSectionNameOffset); 666 } 667 } 668 } 669 } 670 } else { 671 if (fallback_style != DumpStyleInvalid) 672 return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size); 673 return false; 674 } 675 break; 676 677 case DumpStyleDetailedSymbolContext: 678 if (IsSectionOffset()) { 679 ModuleSP module_sp(GetModule()); 680 if (module_sp) { 681 SymbolContext sc; 682 module_sp->ResolveSymbolContextForAddress( 683 *this, eSymbolContextEverything | eSymbolContextVariable, sc); 684 if (sc.symbol) { 685 // If we have just a symbol make sure it is in the same section 686 // as our address. If it isn't, then we might have just found 687 // the last symbol that came before the address that we are 688 // looking up that has nothing to do with our address lookup. 689 if (sc.symbol->ValueIsAddress() && 690 sc.symbol->GetAddressRef().GetSection() != GetSection()) 691 sc.symbol = nullptr; 692 } 693 sc.GetDescription(s, eDescriptionLevelBrief, target); 694 695 if (sc.block) { 696 bool can_create = true; 697 bool get_parent_variables = true; 698 bool stop_if_block_is_inlined_function = false; 699 VariableList variable_list; 700 sc.block->AppendVariables(can_create, get_parent_variables, 701 stop_if_block_is_inlined_function, 702 [](Variable *) { return true; }, 703 &variable_list); 704 705 const size_t num_variables = variable_list.GetSize(); 706 for (size_t var_idx = 0; var_idx < num_variables; ++var_idx) { 707 Variable *var = variable_list.GetVariableAtIndex(var_idx).get(); 708 if (var && var->LocationIsValidForAddress(*this)) { 709 s->Indent(); 710 s->Printf(" Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\"", 711 var->GetID(), var->GetName().GetCString()); 712 Type *type = var->GetType(); 713 if (type) 714 s->Printf(", type = \"%s\"", type->GetName().GetCString()); 715 else 716 s->PutCString(", type = <unknown>"); 717 s->PutCString(", location = "); 718 var->DumpLocationForAddress(s, *this); 719 s->PutCString(", decl = "); 720 var->GetDeclaration().DumpStopContext(s, false); 721 s->EOL(); 722 } 723 } 724 } 725 } 726 } else { 727 if (fallback_style != DumpStyleInvalid) 728 return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size); 729 return false; 730 } 731 break; 732 733 case DumpStyleResolvedPointerDescription: { 734 Process *process = exe_ctx.GetProcessPtr(); 735 if (process) { 736 addr_t load_addr = GetLoadAddress(target); 737 if (load_addr != LLDB_INVALID_ADDRESS) { 738 Status memory_error; 739 addr_t dereferenced_load_addr = 740 process->ReadPointerFromMemory(load_addr, memory_error); 741 if (dereferenced_load_addr != LLDB_INVALID_ADDRESS) { 742 Address dereferenced_addr; 743 if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr, 744 target)) { 745 StreamString strm; 746 if (dereferenced_addr.Dump(&strm, exe_scope, 747 DumpStyleResolvedDescription, 748 DumpStyleInvalid, addr_size)) { 749 s->Address(dereferenced_load_addr, addr_size, " -> ", " "); 750 s->Write(strm.GetString().data(), strm.GetSize()); 751 return true; 752 } 753 } 754 } 755 } 756 } 757 if (fallback_style != DumpStyleInvalid) 758 return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size); 759 return false; 760 } break; 761 } 762 763 return true; 764 } 765 766 bool Address::SectionWasDeleted() const { 767 if (GetSection()) 768 return false; 769 return SectionWasDeletedPrivate(); 770 } 771 772 bool Address::SectionWasDeletedPrivate() const { 773 lldb::SectionWP empty_section_wp; 774 775 // If either call to "std::weak_ptr::owner_before(...) value returns true, 776 // this 777 // indicates that m_section_wp once contained (possibly still does) a 778 // reference 779 // to a valid shared pointer. This helps us know if we had a valid reference 780 // to 781 // a section which is now invalid because the module it was in was 782 // unloaded/deleted, 783 // or if the address doesn't have a valid reference to a section. 784 return empty_section_wp.owner_before(m_section_wp) || 785 m_section_wp.owner_before(empty_section_wp); 786 } 787 788 uint32_t Address::CalculateSymbolContext(SymbolContext *sc, 789 uint32_t resolve_scope) const { 790 sc->Clear(false); 791 // Absolute addresses don't have enough information to reconstruct even their 792 // target. 793 794 SectionSP section_sp(GetSection()); 795 if (section_sp) { 796 ModuleSP module_sp(section_sp->GetModule()); 797 if (module_sp) { 798 sc->module_sp = module_sp; 799 if (sc->module_sp) 800 return sc->module_sp->ResolveSymbolContextForAddress( 801 *this, resolve_scope, *sc); 802 } 803 } 804 return 0; 805 } 806 807 ModuleSP Address::CalculateSymbolContextModule() const { 808 SectionSP section_sp(GetSection()); 809 if (section_sp) 810 return section_sp->GetModule(); 811 return ModuleSP(); 812 } 813 814 CompileUnit *Address::CalculateSymbolContextCompileUnit() const { 815 SectionSP section_sp(GetSection()); 816 if (section_sp) { 817 SymbolContext sc; 818 sc.module_sp = section_sp->GetModule(); 819 if (sc.module_sp) { 820 sc.module_sp->ResolveSymbolContextForAddress(*this, 821 eSymbolContextCompUnit, sc); 822 return sc.comp_unit; 823 } 824 } 825 return nullptr; 826 } 827 828 Function *Address::CalculateSymbolContextFunction() const { 829 SectionSP section_sp(GetSection()); 830 if (section_sp) { 831 SymbolContext sc; 832 sc.module_sp = section_sp->GetModule(); 833 if (sc.module_sp) { 834 sc.module_sp->ResolveSymbolContextForAddress(*this, 835 eSymbolContextFunction, sc); 836 return sc.function; 837 } 838 } 839 return nullptr; 840 } 841 842 Block *Address::CalculateSymbolContextBlock() const { 843 SectionSP section_sp(GetSection()); 844 if (section_sp) { 845 SymbolContext sc; 846 sc.module_sp = section_sp->GetModule(); 847 if (sc.module_sp) { 848 sc.module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextBlock, 849 sc); 850 return sc.block; 851 } 852 } 853 return nullptr; 854 } 855 856 Symbol *Address::CalculateSymbolContextSymbol() const { 857 SectionSP section_sp(GetSection()); 858 if (section_sp) { 859 SymbolContext sc; 860 sc.module_sp = section_sp->GetModule(); 861 if (sc.module_sp) { 862 sc.module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextSymbol, 863 sc); 864 return sc.symbol; 865 } 866 } 867 return nullptr; 868 } 869 870 bool Address::CalculateSymbolContextLineEntry(LineEntry &line_entry) const { 871 SectionSP section_sp(GetSection()); 872 if (section_sp) { 873 SymbolContext sc; 874 sc.module_sp = section_sp->GetModule(); 875 if (sc.module_sp) { 876 sc.module_sp->ResolveSymbolContextForAddress(*this, 877 eSymbolContextLineEntry, sc); 878 if (sc.line_entry.IsValid()) { 879 line_entry = sc.line_entry; 880 return true; 881 } 882 } 883 } 884 line_entry.Clear(); 885 return false; 886 } 887 888 int Address::CompareFileAddress(const Address &a, const Address &b) { 889 addr_t a_file_addr = a.GetFileAddress(); 890 addr_t b_file_addr = b.GetFileAddress(); 891 if (a_file_addr < b_file_addr) 892 return -1; 893 if (a_file_addr > b_file_addr) 894 return +1; 895 return 0; 896 } 897 898 int Address::CompareLoadAddress(const Address &a, const Address &b, 899 Target *target) { 900 assert(target != nullptr); 901 addr_t a_load_addr = a.GetLoadAddress(target); 902 addr_t b_load_addr = b.GetLoadAddress(target); 903 if (a_load_addr < b_load_addr) 904 return -1; 905 if (a_load_addr > b_load_addr) 906 return +1; 907 return 0; 908 } 909 910 int Address::CompareModulePointerAndOffset(const Address &a, const Address &b) { 911 ModuleSP a_module_sp(a.GetModule()); 912 ModuleSP b_module_sp(b.GetModule()); 913 Module *a_module = a_module_sp.get(); 914 Module *b_module = b_module_sp.get(); 915 if (a_module < b_module) 916 return -1; 917 if (a_module > b_module) 918 return +1; 919 // Modules are the same, just compare the file address since they should 920 // be unique 921 addr_t a_file_addr = a.GetFileAddress(); 922 addr_t b_file_addr = b.GetFileAddress(); 923 if (a_file_addr < b_file_addr) 924 return -1; 925 if (a_file_addr > b_file_addr) 926 return +1; 927 return 0; 928 } 929 930 size_t Address::MemorySize() const { 931 // Noting special for the memory size of a single Address object, 932 // it is just the size of itself. 933 return sizeof(Address); 934 } 935 936 //---------------------------------------------------------------------- 937 // NOTE: Be careful using this operator. It can correctly compare two 938 // addresses from the same Module correctly. It can't compare two 939 // addresses from different modules in any meaningful way, but it will 940 // compare the module pointers. 941 // 942 // To sum things up: 943 // - works great for addresses within the same module 944 // - it works for addresses across multiple modules, but don't expect the 945 // address results to make much sense 946 // 947 // This basically lets Address objects be used in ordered collection 948 // classes. 949 //---------------------------------------------------------------------- 950 951 bool lldb_private::operator<(const Address &lhs, const Address &rhs) { 952 ModuleSP lhs_module_sp(lhs.GetModule()); 953 ModuleSP rhs_module_sp(rhs.GetModule()); 954 Module *lhs_module = lhs_module_sp.get(); 955 Module *rhs_module = rhs_module_sp.get(); 956 if (lhs_module == rhs_module) { 957 // Addresses are in the same module, just compare the file addresses 958 return lhs.GetFileAddress() < rhs.GetFileAddress(); 959 } else { 960 // The addresses are from different modules, just use the module 961 // pointer value to get consistent ordering 962 return lhs_module < rhs_module; 963 } 964 } 965 966 bool lldb_private::operator>(const Address &lhs, const Address &rhs) { 967 ModuleSP lhs_module_sp(lhs.GetModule()); 968 ModuleSP rhs_module_sp(rhs.GetModule()); 969 Module *lhs_module = lhs_module_sp.get(); 970 Module *rhs_module = rhs_module_sp.get(); 971 if (lhs_module == rhs_module) { 972 // Addresses are in the same module, just compare the file addresses 973 return lhs.GetFileAddress() > rhs.GetFileAddress(); 974 } else { 975 // The addresses are from different modules, just use the module 976 // pointer value to get consistent ordering 977 return lhs_module > rhs_module; 978 } 979 } 980 981 // The operator == checks for exact equality only (same section, same offset) 982 bool lldb_private::operator==(const Address &a, const Address &rhs) { 983 return a.GetOffset() == rhs.GetOffset() && a.GetSection() == rhs.GetSection(); 984 } 985 986 // The operator != checks for exact inequality only (differing section, or 987 // different offset) 988 bool lldb_private::operator!=(const Address &a, const Address &rhs) { 989 return a.GetOffset() != rhs.GetOffset() || a.GetSection() != rhs.GetSection(); 990 } 991 992 AddressClass Address::GetAddressClass() const { 993 ModuleSP module_sp(GetModule()); 994 if (module_sp) { 995 ObjectFile *obj_file = module_sp->GetObjectFile(); 996 if (obj_file) { 997 // Give the symbol vendor a chance to add to the unified section list. 998 module_sp->GetSymbolVendor(); 999 return obj_file->GetAddressClass(GetFileAddress()); 1000 } 1001 } 1002 return eAddressClassUnknown; 1003 } 1004 1005 bool Address::SetLoadAddress(lldb::addr_t load_addr, Target *target, 1006 bool allow_section_end) { 1007 if (target && target->GetSectionLoadList().ResolveLoadAddress( 1008 load_addr, *this, allow_section_end)) 1009 return true; 1010 m_section_wp.reset(); 1011 m_offset = load_addr; 1012 return false; 1013 } 1014