1 //===-- Section.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/Section.h" 11 #include "lldb/Core/Module.h" 12 #include "lldb/Symbol/ObjectFile.h" 13 #include "lldb/Target/Target.h" 14 15 using namespace lldb; 16 using namespace lldb_private; 17 18 Section::Section 19 ( 20 Section *parent, 21 Module* module, 22 user_id_t sect_id, 23 const ConstString &name, 24 SectionType sect_type, 25 addr_t file_addr, 26 addr_t byte_size, 27 uint64_t file_offset, 28 uint64_t file_size, 29 uint32_t flags 30 ) : 31 ModuleChild (module), 32 UserID (sect_id), 33 Flags (flags), 34 m_parent (parent), 35 m_name (name), 36 m_type (sect_type), 37 m_file_addr (file_addr), 38 m_byte_size (byte_size), 39 m_file_offset (file_offset), 40 m_file_size (file_size), 41 m_children (), 42 m_fake (false), 43 m_linked_section(NULL), 44 m_linked_offset (0) 45 { 46 } 47 48 Section::~Section() 49 { 50 } 51 52 53 // Get a valid shared pointer to this section object 54 SectionSP 55 Section::GetSharedPointer() const 56 { 57 SectionSP this_sp; 58 if (m_parent) 59 this_sp = m_parent->GetChildren().GetSharedPointer (this, false); 60 else 61 { 62 ObjectFile *objfile = m_module->GetObjectFile(); 63 if (objfile) 64 { 65 SectionList *section_list = objfile->GetSectionList(); 66 if (section_list) 67 this_sp = section_list->GetSharedPointer (this, false); 68 } 69 } 70 return this_sp; 71 } 72 73 74 75 ConstString& 76 Section::GetName() 77 { 78 if (m_linked_section) 79 return const_cast<Section *>(m_linked_section)->GetName(); 80 return m_name; 81 } 82 83 const ConstString& 84 Section::GetName() const 85 { 86 if (m_linked_section) 87 return m_linked_section->GetName(); 88 return m_name; 89 } 90 91 addr_t 92 Section::GetFileAddress () const 93 { 94 if (m_parent) 95 { 96 // This section has a parent which means m_file_addr is an offset into 97 // the parent section, so the file address for this section is the file 98 // address of the parent plus the offset 99 return m_parent->GetFileAddress() + m_file_addr; 100 } 101 // This section has no parent, so m_file_addr is the file base address 102 return m_file_addr; 103 } 104 105 addr_t 106 Section::GetLinkedFileAddress () const 107 { 108 if (m_linked_section) 109 return m_linked_section->GetFileAddress() + m_linked_offset; 110 return LLDB_INVALID_ADDRESS; 111 } 112 113 114 addr_t 115 Section::GetLoadBaseAddress (Target *target) const 116 { 117 addr_t load_base_addr = LLDB_INVALID_ADDRESS; 118 if (m_linked_section) 119 { 120 load_base_addr = m_linked_section->GetLoadBaseAddress(target) + m_linked_offset; 121 } 122 else 123 if (m_parent) 124 { 125 load_base_addr = m_parent->GetLoadBaseAddress (target); 126 if (load_base_addr != LLDB_INVALID_ADDRESS) 127 load_base_addr += GetOffset(); 128 } 129 else 130 { 131 load_base_addr = target->GetSectionLoadList().GetSectionLoadAddress (this); 132 } 133 134 return load_base_addr; 135 } 136 137 bool 138 Section::ResolveContainedAddress (addr_t offset, Address &so_addr) const 139 { 140 const uint32_t num_children = m_children.GetSize(); 141 if (num_children > 0) 142 { 143 for (uint32_t i=0; i<num_children; i++) 144 { 145 Section* child_section = m_children.GetSectionAtIndex (i).get(); 146 147 addr_t child_offset = child_section->GetOffset(); 148 if (child_offset <= offset && offset - child_offset < child_section->GetByteSize()) 149 return child_section->ResolveContainedAddress (offset - child_offset, so_addr); 150 } 151 } 152 if (m_linked_section) 153 { 154 so_addr.SetOffset(m_linked_offset + offset); 155 so_addr.SetSection(m_linked_section); 156 } 157 else 158 { 159 so_addr.SetOffset(offset); 160 so_addr.SetSection(this); 161 } 162 return true; 163 } 164 165 bool 166 Section::ContainsFileAddress (addr_t vm_addr) const 167 { 168 const addr_t file_addr = GetFileAddress(); 169 if (file_addr != LLDB_INVALID_ADDRESS) 170 { 171 if (file_addr <= vm_addr) 172 { 173 const addr_t offset = vm_addr - file_addr; 174 return offset < GetByteSize(); 175 } 176 } 177 return false; 178 } 179 180 bool 181 Section::ContainsLinkedFileAddress (addr_t vm_addr) const 182 { 183 const addr_t linked_file_addr = GetLinkedFileAddress(); 184 if (linked_file_addr != LLDB_INVALID_ADDRESS) 185 { 186 if (linked_file_addr <= vm_addr) 187 { 188 const addr_t offset = vm_addr - linked_file_addr; 189 return offset < GetByteSize(); 190 } 191 } 192 return false; 193 } 194 195 int 196 Section::Compare (const Section& a, const Section& b) 197 { 198 if (&a == &b) 199 return 0; 200 201 const Module* a_module = a.GetModule(); 202 const Module* b_module = b.GetModule(); 203 if (a_module == b_module) 204 { 205 user_id_t a_sect_uid = a.GetID(); 206 user_id_t b_sect_uid = b.GetID(); 207 if (a_sect_uid < b_sect_uid) 208 return -1; 209 if (a_sect_uid > b_sect_uid) 210 return 1; 211 return 0; 212 } 213 else 214 { 215 // The modules are different, just compare the module pointers 216 if (a_module < b_module) 217 return -1; 218 else 219 return 1; // We already know the modules aren't equal 220 } 221 } 222 223 224 void 225 Section::Dump (Stream *s, Target *target, uint32_t depth) const 226 { 227 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); 228 s->Indent(); 229 s->Printf("0x%8.8x %-14s ", GetID(), GetSectionTypeAsCString (m_type)); 230 bool resolved = true; 231 addr_t addr = LLDB_INVALID_ADDRESS; 232 233 if (GetByteSize() == 0) 234 s->Printf("%39s", ""); 235 else 236 { 237 if (target && m_linked_section == NULL) 238 addr = GetLoadBaseAddress (target); 239 240 if (addr == LLDB_INVALID_ADDRESS) 241 { 242 if (target) 243 resolved = false; 244 addr = GetFileAddress(); 245 } 246 247 VMRange range(addr, addr + m_byte_size); 248 range.Dump (s, 0); 249 } 250 251 s->Printf("%c 0x%8.8llx 0x%8.8llx 0x%8.8x ", resolved ? ' ' : '*', m_file_offset, m_file_size, Get()); 252 253 DumpName (s); 254 255 s->EOL(); 256 257 if (m_linked_section) 258 { 259 addr = LLDB_INVALID_ADDRESS; 260 resolved = true; 261 if (target) 262 { 263 addr = m_linked_section->GetLoadBaseAddress(target); 264 if (addr != LLDB_INVALID_ADDRESS) 265 addr += m_linked_offset; 266 } 267 268 if (addr == LLDB_INVALID_ADDRESS) 269 { 270 if (target) 271 resolved = false; 272 addr = m_linked_section->GetFileAddress() + m_linked_offset; 273 } 274 275 int indent = 26 + s->GetIndentLevel(); 276 s->Printf("%*.*s", indent, indent, ""); 277 VMRange linked_range(addr, addr + m_byte_size); 278 linked_range.Dump (s, 0); 279 indent = 3 * (sizeof(uint32_t) * 2 + 2 + 1) + 1; 280 s->Printf("%c%*.*s", resolved ? ' ' : '*', indent, indent, ""); 281 282 m_linked_section->DumpName(s); 283 s->Printf(" + 0x%llx\n", m_linked_offset); 284 } 285 286 if (depth > 0) 287 m_children.Dump(s, target, false, depth - 1); 288 } 289 290 void 291 Section::DumpName (Stream *s) const 292 { 293 if (m_parent == NULL) 294 { 295 // The top most section prints the module basename 296 const char *module_basename = m_module->GetFileSpec().GetFilename().AsCString(); 297 if (module_basename && module_basename[0]) 298 s->Printf("%s.", module_basename); 299 } 300 else 301 { 302 m_parent->DumpName (s); 303 s->PutChar('.'); 304 } 305 m_name.Dump(s); 306 } 307 308 //---------------------------------------------------------------------- 309 // Get the section data from a complete contiguous copy of the 310 // entire executable image. 311 //---------------------------------------------------------------------- 312 size_t 313 Section::GetSectionDataFromImage (const DataExtractor& image_data, DataExtractor& section_data) const 314 { 315 size_t file_size = GetByteSize(); 316 if (file_size > 0) 317 { 318 off_t file_offset = GetFileOffset(); 319 if (section_data.SetData (image_data, file_offset, file_size) == file_size) 320 return true; 321 } 322 return false; 323 } 324 325 size_t 326 Section::ReadSectionDataFromObjectFile (const ObjectFile* objfile, off_t section_offset, void *dst, size_t dst_len) const 327 { 328 if (objfile && dst && dst_len) 329 { 330 const FileSpec& file = objfile->GetFileSpec(); 331 332 if (file) 333 { 334 size_t bytes_left = dst_len; 335 size_t bytes_read = 0; 336 const uint64_t file_size = GetFileSize(); 337 if (section_offset < file_size) 338 { 339 off_t section_file_offset = objfile->GetOffset() + GetFileOffset() + section_offset; 340 bytes_read = file.ReadFileContents (section_file_offset, dst, dst_len); 341 if (bytes_read >= dst_len) 342 return bytes_read; 343 bytes_left -= bytes_read; 344 } 345 346 const uint64_t byte_size = GetByteSize(); 347 if (section_offset + bytes_read < byte_size) 348 { 349 memset ((uint8_t*)dst + bytes_read, 0, bytes_left); 350 bytes_read += bytes_left; 351 } 352 return bytes_read; 353 } 354 } 355 return 0; 356 } 357 358 //---------------------------------------------------------------------- 359 // Get the section data the file on disk 360 //---------------------------------------------------------------------- 361 size_t 362 Section::ReadSectionDataFromObjectFile(const ObjectFile* objfile, DataExtractor& section_data) const 363 { 364 if (objfile == NULL) 365 return 0; 366 367 const FileSpec& file = objfile->GetFileSpec(); 368 369 if (file) 370 { 371 size_t section_file_size = GetByteSize(); 372 if (section_file_size > 0) 373 { 374 off_t section_file_offset = GetFileOffset() + objfile->GetOffset(); 375 DataBufferSP section_data_sp(file.ReadFileContents(section_file_offset, section_file_size)); 376 377 section_data.SetByteOrder(objfile->GetByteOrder()); 378 section_data.SetAddressByteSize(objfile->GetAddressByteSize()); 379 return section_data.SetData (section_data_sp); 380 } 381 } 382 return 0; 383 } 384 385 size_t 386 Section::MemoryMapSectionDataFromObjectFile(const ObjectFile* objfile, DataExtractor& section_data) const 387 { 388 if (objfile == NULL) 389 return 0; 390 391 const FileSpec& file = objfile->GetFileSpec(); 392 393 if (file) 394 { 395 size_t section_file_size = GetFileSize(); 396 if (section_file_size > 0) 397 { 398 off_t section_file_offset = GetFileOffset() + objfile->GetOffset(); 399 DataBufferSP section_data_sp(file.MemoryMapFileContents(section_file_offset, section_file_size)); 400 section_data.SetByteOrder(objfile->GetByteOrder()); 401 section_data.SetAddressByteSize(objfile->GetAddressByteSize()); 402 return section_data.SetData (section_data_sp); 403 } 404 } 405 return 0; 406 } 407 408 bool 409 Section::IsDescendant (const Section *section) 410 { 411 if (this == section) 412 return true; 413 if (m_parent) 414 return m_parent->IsDescendant (section); 415 return false; 416 } 417 418 bool 419 Section::Slide (addr_t slide_amount, bool slide_children) 420 { 421 if (m_file_addr != LLDB_INVALID_ADDRESS) 422 { 423 if (slide_amount == 0) 424 return true; 425 426 m_file_addr += slide_amount; 427 428 if (slide_children) 429 m_children.Slide (slide_amount, slide_children); 430 431 return true; 432 } 433 return false; 434 } 435 436 void 437 Section::SetLinkedLocation (const Section *linked_section, uint64_t linked_offset) 438 { 439 if (linked_section) 440 m_module = linked_section->GetModule(); 441 m_linked_section = linked_section; 442 m_linked_offset = linked_offset; 443 } 444 445 #pragma mark SectionList 446 447 SectionList::SectionList () : 448 m_sections() 449 { 450 } 451 452 453 SectionList::~SectionList () 454 { 455 } 456 457 uint32_t 458 SectionList::AddSection (SectionSP& sect_sp) 459 { 460 uint32_t section_index = m_sections.size(); 461 m_sections.push_back(sect_sp); 462 return section_index; 463 } 464 465 uint32_t 466 SectionList::FindSectionIndex (const Section* sect) 467 { 468 iterator sect_iter; 469 iterator begin = m_sections.begin(); 470 iterator end = m_sections.end(); 471 for (sect_iter = begin; sect_iter != end; ++sect_iter) 472 { 473 if (sect_iter->get() == sect) 474 { 475 // The secton was already in this section list 476 return std::distance (begin, sect_iter); 477 } 478 } 479 return UINT32_MAX; 480 } 481 482 uint32_t 483 SectionList::AddUniqueSection (SectionSP& sect_sp) 484 { 485 uint32_t sect_idx = FindSectionIndex (sect_sp.get()); 486 if (sect_idx == UINT32_MAX) 487 sect_idx = AddSection (sect_sp); 488 return sect_idx; 489 } 490 491 492 bool 493 SectionList::ReplaceSection (user_id_t sect_id, SectionSP& sect_sp, uint32_t depth) 494 { 495 iterator sect_iter, end = m_sections.end(); 496 for (sect_iter = m_sections.begin(); sect_iter != end; ++sect_iter) 497 { 498 if ((*sect_iter)->GetID() == sect_id) 499 { 500 *sect_iter = sect_sp; 501 return true; 502 } 503 else if (depth > 0) 504 { 505 if ((*sect_iter)->GetChildren().ReplaceSection(sect_id, sect_sp, depth - 1)) 506 return true; 507 } 508 } 509 return false; 510 } 511 512 513 size_t 514 SectionList::GetNumSections (uint32_t depth) const 515 { 516 size_t count = m_sections.size(); 517 if (depth > 0) 518 { 519 const_iterator sect_iter, end = m_sections.end(); 520 for (sect_iter = m_sections.begin(); sect_iter != end; ++sect_iter) 521 { 522 count += (*sect_iter)->GetChildren().GetNumSections(depth - 1); 523 } 524 } 525 return count; 526 } 527 528 SectionSP 529 SectionList::GetSectionAtIndex (uint32_t idx) const 530 { 531 SectionSP sect_sp; 532 if (idx < m_sections.size()) 533 sect_sp = m_sections[idx]; 534 return sect_sp; 535 } 536 537 SectionSP 538 SectionList::FindSectionByName (const ConstString §ion_dstr) const 539 { 540 SectionSP sect_sp; 541 // Check if we have a valid section string 542 if (section_dstr) 543 { 544 const_iterator sect_iter; 545 const_iterator end = m_sections.end(); 546 for (sect_iter = m_sections.begin(); sect_iter != end && sect_sp.get() == NULL; ++sect_iter) 547 { 548 if ((*sect_iter)->GetName() == section_dstr) 549 { 550 sect_sp = *sect_iter; 551 } 552 else 553 { 554 sect_sp = (*sect_iter)->GetChildren().FindSectionByName(section_dstr); 555 } 556 } 557 } 558 return sect_sp; 559 } 560 561 SectionSP 562 SectionList::FindSectionByID (user_id_t sect_id) const 563 { 564 SectionSP sect_sp; 565 if (sect_id) 566 { 567 const_iterator sect_iter; 568 const_iterator end = m_sections.end(); 569 for (sect_iter = m_sections.begin(); sect_iter != end && sect_sp.get() == NULL; ++sect_iter) 570 { 571 if ((*sect_iter)->GetID() == sect_id) 572 { 573 sect_sp = *sect_iter; 574 break; 575 } 576 else 577 { 578 sect_sp = (*sect_iter)->GetChildren().FindSectionByID (sect_id); 579 } 580 } 581 } 582 return sect_sp; 583 } 584 585 586 SectionSP 587 SectionList::FindSectionByType (SectionType sect_type, bool check_children, uint32_t start_idx) const 588 { 589 SectionSP sect_sp; 590 uint32_t num_sections = m_sections.size(); 591 for (uint32_t idx = start_idx; idx < num_sections; ++idx) 592 { 593 if (m_sections[idx]->GetType() == sect_type) 594 { 595 sect_sp = m_sections[idx]; 596 break; 597 } 598 else if (check_children) 599 { 600 sect_sp = m_sections[idx]->GetChildren().FindSectionByType (sect_type, check_children, 0); 601 if (sect_sp) 602 break; 603 } 604 } 605 return sect_sp; 606 } 607 608 SectionSP 609 SectionList::GetSharedPointer (const Section *section, bool check_children) const 610 { 611 SectionSP sect_sp; 612 if (section) 613 { 614 const_iterator sect_iter; 615 const_iterator end = m_sections.end(); 616 for (sect_iter = m_sections.begin(); sect_iter != end && sect_sp.get() == NULL; ++sect_iter) 617 { 618 if (sect_iter->get() == section) 619 { 620 sect_sp = *sect_iter; 621 break; 622 } 623 else if (check_children) 624 { 625 sect_sp = (*sect_iter)->GetChildren().GetSharedPointer (section, true); 626 } 627 } 628 } 629 return sect_sp; 630 } 631 632 633 634 SectionSP 635 SectionList::FindSectionContainingFileAddress (addr_t vm_addr, uint32_t depth) const 636 { 637 SectionSP sect_sp; 638 const_iterator sect_iter; 639 const_iterator end = m_sections.end(); 640 for (sect_iter = m_sections.begin(); sect_iter != end && sect_sp.get() == NULL; ++sect_iter) 641 { 642 Section *sect = sect_iter->get(); 643 if (sect->ContainsFileAddress (vm_addr)) 644 { 645 // The file address is in this section. We need to make sure one of our child 646 // sections doesn't contain this address as well as obeying the depth limit 647 // that was passed in. 648 if (depth > 0) 649 sect_sp = sect->GetChildren().FindSectionContainingFileAddress(vm_addr, depth - 1); 650 651 if (sect_sp.get() == NULL && !sect->IsFake()) 652 sect_sp = *sect_iter; 653 } 654 } 655 return sect_sp; 656 } 657 658 659 SectionSP 660 SectionList::FindSectionContainingLinkedFileAddress (addr_t vm_addr, uint32_t depth) const 661 { 662 SectionSP sect_sp; 663 const_iterator sect_iter; 664 const_iterator end = m_sections.end(); 665 for (sect_iter = m_sections.begin(); sect_iter != end && sect_sp.get() == NULL; ++sect_iter) 666 { 667 Section *sect = sect_iter->get(); 668 if (sect->ContainsLinkedFileAddress (vm_addr)) 669 { 670 sect_sp = *sect_iter; 671 } 672 else if (depth > 0) 673 { 674 sect_sp = sect->GetChildren().FindSectionContainingLinkedFileAddress (vm_addr, depth - 1); 675 } 676 } 677 return sect_sp; 678 } 679 680 bool 681 SectionList::ContainsSection(user_id_t sect_id) const 682 { 683 return FindSectionByID (sect_id).get() != NULL; 684 } 685 686 void 687 SectionList::Dump (Stream *s, Target *target, bool show_header, uint32_t depth) const 688 { 689 bool target_has_loaded_sections = target && !target->GetSectionLoadList().IsEmpty(); 690 if (show_header && !m_sections.empty()) 691 { 692 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); 693 // s->Indent(); 694 // s->PutCString( "SectionList\n"); 695 // s->IndentMore(); 696 // s->Printf("%*s", 2*(sizeof(void *) + 2), ""); 697 s->Indent(); 698 s->Printf("SectID Type %s Address File Off. File Size Flags Section Name\n", target_has_loaded_sections ? "Load" : "File"); 699 // s->Printf("%*s", 2*(sizeof(void *) + 2), ""); 700 s->Indent(); 701 s->PutCString("---------- -------------- --------------------------------------- ---------- ---------- ---------- ----------------------------\n"); 702 } 703 704 705 const_iterator sect_iter; 706 const_iterator end = m_sections.end(); 707 for (sect_iter = m_sections.begin(); sect_iter != end; ++sect_iter) 708 { 709 (*sect_iter)->Dump(s, target_has_loaded_sections ? target : NULL, depth); 710 } 711 712 if (show_header && !m_sections.empty()) 713 s->IndentLess(); 714 715 } 716 717 size_t 718 SectionList::Slide (addr_t slide_amount, bool slide_children) 719 { 720 size_t count = 0; 721 const_iterator pos, end = m_sections.end(); 722 for (pos = m_sections.begin(); pos != end; ++pos) 723 { 724 if ((*pos)->Slide(slide_amount, slide_children)) 725 ++count; 726 } 727 return count; 728 } 729 730