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