1 //===-- ObjectFileMachO.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 "llvm/ADT/StringRef.h" 11 #include "llvm/Support/MachO.h" 12 13 #include "ObjectFileMachO.h" 14 15 #include "lldb/Core/ArchSpec.h" 16 #include "lldb/Core/DataBuffer.h" 17 #include "lldb/Core/FileSpecList.h" 18 #include "lldb/Core/Module.h" 19 #include "lldb/Core/PluginManager.h" 20 #include "lldb/Core/Section.h" 21 #include "lldb/Core/StreamFile.h" 22 #include "lldb/Core/StreamString.h" 23 #include "lldb/Core/Timer.h" 24 #include "lldb/Core/UUID.h" 25 #include "lldb/Host/Host.h" 26 #include "lldb/Host/FileSpec.h" 27 #include "lldb/Symbol/ClangNamespaceDecl.h" 28 #include "lldb/Symbol/ObjectFile.h" 29 #include "lldb/Target/Platform.h" 30 #include "lldb/Target/Process.h" 31 #include "lldb/Target/Target.h" 32 #include "Plugins/Process/Utility/RegisterContextDarwin_arm.h" 33 #include "Plugins/Process/Utility/RegisterContextDarwin_i386.h" 34 #include "Plugins/Process/Utility/RegisterContextDarwin_x86_64.h" 35 36 37 using namespace lldb; 38 using namespace lldb_private; 39 using namespace llvm::MachO; 40 41 class RegisterContextDarwin_x86_64_Mach : public RegisterContextDarwin_x86_64 42 { 43 public: 44 RegisterContextDarwin_x86_64_Mach (lldb_private::Thread &thread, const DataExtractor &data) : 45 RegisterContextDarwin_x86_64 (thread, 0) 46 { 47 SetRegisterDataFrom_LC_THREAD (data); 48 } 49 50 virtual void 51 InvalidateAllRegisters () 52 { 53 // Do nothing... registers are always valid... 54 } 55 56 void 57 SetRegisterDataFrom_LC_THREAD (const DataExtractor &data) 58 { 59 uint32_t offset = 0; 60 SetError (GPRRegSet, Read, -1); 61 SetError (FPURegSet, Read, -1); 62 SetError (EXCRegSet, Read, -1); 63 bool done = false; 64 65 while (!done) 66 { 67 int flavor = data.GetU32 (&offset); 68 if (flavor == 0) 69 done = true; 70 else 71 { 72 uint32_t i; 73 uint32_t count = data.GetU32 (&offset); 74 switch (flavor) 75 { 76 case GPRRegSet: 77 for (i=0; i<count; ++i) 78 (&gpr.rax)[i] = data.GetU64(&offset); 79 SetError (GPRRegSet, Read, 0); 80 done = true; 81 82 break; 83 case FPURegSet: 84 // TODO: fill in FPU regs.... 85 //SetError (FPURegSet, Read, -1); 86 done = true; 87 88 break; 89 case EXCRegSet: 90 exc.trapno = data.GetU32(&offset); 91 exc.err = data.GetU32(&offset); 92 exc.faultvaddr = data.GetU64(&offset); 93 SetError (EXCRegSet, Read, 0); 94 done = true; 95 break; 96 case 7: 97 case 8: 98 case 9: 99 // fancy flavors that encapsulate of the the above 100 // falvors... 101 break; 102 103 default: 104 done = true; 105 break; 106 } 107 } 108 } 109 } 110 protected: 111 virtual int 112 DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr) 113 { 114 return 0; 115 } 116 117 virtual int 118 DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu) 119 { 120 return 0; 121 } 122 123 virtual int 124 DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc) 125 { 126 return 0; 127 } 128 129 virtual int 130 DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr) 131 { 132 return 0; 133 } 134 135 virtual int 136 DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu) 137 { 138 return 0; 139 } 140 141 virtual int 142 DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc) 143 { 144 return 0; 145 } 146 }; 147 148 149 class RegisterContextDarwin_i386_Mach : public RegisterContextDarwin_i386 150 { 151 public: 152 RegisterContextDarwin_i386_Mach (lldb_private::Thread &thread, const DataExtractor &data) : 153 RegisterContextDarwin_i386 (thread, 0) 154 { 155 SetRegisterDataFrom_LC_THREAD (data); 156 } 157 158 virtual void 159 InvalidateAllRegisters () 160 { 161 // Do nothing... registers are always valid... 162 } 163 164 void 165 SetRegisterDataFrom_LC_THREAD (const DataExtractor &data) 166 { 167 uint32_t offset = 0; 168 SetError (GPRRegSet, Read, -1); 169 SetError (FPURegSet, Read, -1); 170 SetError (EXCRegSet, Read, -1); 171 bool done = false; 172 173 while (!done) 174 { 175 int flavor = data.GetU32 (&offset); 176 if (flavor == 0) 177 done = true; 178 else 179 { 180 uint32_t i; 181 uint32_t count = data.GetU32 (&offset); 182 switch (flavor) 183 { 184 case GPRRegSet: 185 for (i=0; i<count; ++i) 186 (&gpr.eax)[i] = data.GetU32(&offset); 187 SetError (GPRRegSet, Read, 0); 188 done = true; 189 190 break; 191 case FPURegSet: 192 // TODO: fill in FPU regs.... 193 //SetError (FPURegSet, Read, -1); 194 done = true; 195 196 break; 197 case EXCRegSet: 198 exc.trapno = data.GetU32(&offset); 199 exc.err = data.GetU32(&offset); 200 exc.faultvaddr = data.GetU32(&offset); 201 SetError (EXCRegSet, Read, 0); 202 done = true; 203 break; 204 case 7: 205 case 8: 206 case 9: 207 // fancy flavors that encapsulate of the the above 208 // falvors... 209 break; 210 211 default: 212 done = true; 213 break; 214 } 215 } 216 } 217 } 218 protected: 219 virtual int 220 DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr) 221 { 222 return 0; 223 } 224 225 virtual int 226 DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu) 227 { 228 return 0; 229 } 230 231 virtual int 232 DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc) 233 { 234 return 0; 235 } 236 237 virtual int 238 DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr) 239 { 240 return 0; 241 } 242 243 virtual int 244 DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu) 245 { 246 return 0; 247 } 248 249 virtual int 250 DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc) 251 { 252 return 0; 253 } 254 }; 255 256 class RegisterContextDarwin_arm_Mach : public RegisterContextDarwin_arm 257 { 258 public: 259 RegisterContextDarwin_arm_Mach (lldb_private::Thread &thread, const DataExtractor &data) : 260 RegisterContextDarwin_arm (thread, 0) 261 { 262 SetRegisterDataFrom_LC_THREAD (data); 263 } 264 265 virtual void 266 InvalidateAllRegisters () 267 { 268 // Do nothing... registers are always valid... 269 } 270 271 void 272 SetRegisterDataFrom_LC_THREAD (const DataExtractor &data) 273 { 274 uint32_t offset = 0; 275 SetError (GPRRegSet, Read, -1); 276 SetError (FPURegSet, Read, -1); 277 SetError (EXCRegSet, Read, -1); 278 int flavor = data.GetU32 (&offset); 279 uint32_t count = data.GetU32 (&offset); 280 switch (flavor) 281 { 282 case GPRRegSet: 283 for (uint32_t i=0; i<count; ++i) 284 gpr.r[i] = data.GetU32(&offset); 285 SetError (GPRRegSet, Read, 0); 286 break; 287 case FPURegSet: 288 // TODO: fill in FPU regs.... 289 //SetError (FPURegSet, Read, -1); 290 break; 291 case EXCRegSet: 292 exc.exception = data.GetU32(&offset); 293 exc.fsr = data.GetU32(&offset); 294 exc.far = data.GetU32(&offset); 295 SetError (EXCRegSet, Read, 0); 296 break; 297 } 298 } 299 protected: 300 virtual int 301 DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr) 302 { 303 return 0; 304 } 305 306 virtual int 307 DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu) 308 { 309 return 0; 310 } 311 312 virtual int 313 DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc) 314 { 315 return 0; 316 } 317 318 virtual int 319 DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr) 320 { 321 return 0; 322 } 323 324 virtual int 325 DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu) 326 { 327 return 0; 328 } 329 330 virtual int 331 DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc) 332 { 333 return 0; 334 } 335 }; 336 337 #define MACHO_NLIST_ARM_SYMBOL_IS_THUMB 0x0008 338 339 void 340 ObjectFileMachO::Initialize() 341 { 342 PluginManager::RegisterPlugin (GetPluginNameStatic(), 343 GetPluginDescriptionStatic(), 344 CreateInstance, 345 CreateMemoryInstance); 346 } 347 348 void 349 ObjectFileMachO::Terminate() 350 { 351 PluginManager::UnregisterPlugin (CreateInstance); 352 } 353 354 355 const char * 356 ObjectFileMachO::GetPluginNameStatic() 357 { 358 return "object-file.mach-o"; 359 } 360 361 const char * 362 ObjectFileMachO::GetPluginDescriptionStatic() 363 { 364 return "Mach-o object file reader (32 and 64 bit)"; 365 } 366 367 368 ObjectFile * 369 ObjectFileMachO::CreateInstance (const lldb::ModuleSP &module_sp, DataBufferSP& data_sp, const FileSpec* file, addr_t offset, addr_t length) 370 { 371 if (ObjectFileMachO::MagicBytesMatch(data_sp, offset, length)) 372 { 373 std::auto_ptr<ObjectFile> objfile_ap(new ObjectFileMachO (module_sp, data_sp, file, offset, length)); 374 if (objfile_ap.get() && objfile_ap->ParseHeader()) 375 return objfile_ap.release(); 376 } 377 return NULL; 378 } 379 380 ObjectFile * 381 ObjectFileMachO::CreateMemoryInstance (const lldb::ModuleSP &module_sp, 382 DataBufferSP& data_sp, 383 const ProcessSP &process_sp, 384 lldb::addr_t header_addr) 385 { 386 if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) 387 { 388 std::auto_ptr<ObjectFile> objfile_ap(new ObjectFileMachO (module_sp, data_sp, process_sp, header_addr)); 389 if (objfile_ap.get() && objfile_ap->ParseHeader()) 390 return objfile_ap.release(); 391 } 392 return NULL; 393 } 394 395 396 const ConstString & 397 ObjectFileMachO::GetSegmentNameTEXT() 398 { 399 static ConstString g_segment_name_TEXT ("__TEXT"); 400 return g_segment_name_TEXT; 401 } 402 403 const ConstString & 404 ObjectFileMachO::GetSegmentNameDATA() 405 { 406 static ConstString g_segment_name_DATA ("__DATA"); 407 return g_segment_name_DATA; 408 } 409 410 const ConstString & 411 ObjectFileMachO::GetSegmentNameOBJC() 412 { 413 static ConstString g_segment_name_OBJC ("__OBJC"); 414 return g_segment_name_OBJC; 415 } 416 417 const ConstString & 418 ObjectFileMachO::GetSegmentNameLINKEDIT() 419 { 420 static ConstString g_section_name_LINKEDIT ("__LINKEDIT"); 421 return g_section_name_LINKEDIT; 422 } 423 424 const ConstString & 425 ObjectFileMachO::GetSectionNameEHFrame() 426 { 427 static ConstString g_section_name_eh_frame ("__eh_frame"); 428 return g_section_name_eh_frame; 429 } 430 431 432 433 static uint32_t 434 MachHeaderSizeFromMagic(uint32_t magic) 435 { 436 switch (magic) 437 { 438 case HeaderMagic32: 439 case HeaderMagic32Swapped: 440 return sizeof(struct mach_header); 441 442 case HeaderMagic64: 443 case HeaderMagic64Swapped: 444 return sizeof(struct mach_header_64); 445 break; 446 447 default: 448 break; 449 } 450 return 0; 451 } 452 453 454 bool 455 ObjectFileMachO::MagicBytesMatch (DataBufferSP& data_sp, 456 lldb::addr_t data_offset, 457 lldb::addr_t data_length) 458 { 459 DataExtractor data; 460 data.SetData (data_sp, data_offset, data_length); 461 uint32_t offset = 0; 462 uint32_t magic = data.GetU32(&offset); 463 return MachHeaderSizeFromMagic(magic) != 0; 464 } 465 466 467 ObjectFileMachO::ObjectFileMachO(const lldb::ModuleSP &module_sp, DataBufferSP& data_sp, const FileSpec* file, addr_t offset, addr_t length) : 468 ObjectFile(module_sp, file, offset, length, data_sp), 469 m_sections_ap(), 470 m_symtab_ap(), 471 m_mach_segments(), 472 m_mach_sections(), 473 m_entry_point_address(), 474 m_thread_context_offsets(), 475 m_thread_context_offsets_valid(false) 476 { 477 ::memset (&m_header, 0, sizeof(m_header)); 478 ::memset (&m_dysymtab, 0, sizeof(m_dysymtab)); 479 } 480 481 ObjectFileMachO::ObjectFileMachO (const lldb::ModuleSP &module_sp, 482 lldb::DataBufferSP& header_data_sp, 483 const lldb::ProcessSP &process_sp, 484 lldb::addr_t header_addr) : 485 ObjectFile(module_sp, process_sp, header_addr, header_data_sp), 486 m_sections_ap(), 487 m_symtab_ap(), 488 m_mach_segments(), 489 m_mach_sections(), 490 m_entry_point_address(), 491 m_thread_context_offsets(), 492 m_thread_context_offsets_valid(false) 493 { 494 ::memset (&m_header, 0, sizeof(m_header)); 495 ::memset (&m_dysymtab, 0, sizeof(m_dysymtab)); 496 } 497 498 ObjectFileMachO::~ObjectFileMachO() 499 { 500 } 501 502 503 bool 504 ObjectFileMachO::ParseHeader () 505 { 506 ModuleSP module_sp(GetModule()); 507 if (module_sp) 508 { 509 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 510 bool can_parse = false; 511 uint32_t offset = 0; 512 m_data.SetByteOrder (lldb::endian::InlHostByteOrder()); 513 // Leave magic in the original byte order 514 m_header.magic = m_data.GetU32(&offset); 515 switch (m_header.magic) 516 { 517 case HeaderMagic32: 518 m_data.SetByteOrder (lldb::endian::InlHostByteOrder()); 519 m_data.SetAddressByteSize(4); 520 can_parse = true; 521 break; 522 523 case HeaderMagic64: 524 m_data.SetByteOrder (lldb::endian::InlHostByteOrder()); 525 m_data.SetAddressByteSize(8); 526 can_parse = true; 527 break; 528 529 case HeaderMagic32Swapped: 530 m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig); 531 m_data.SetAddressByteSize(4); 532 can_parse = true; 533 break; 534 535 case HeaderMagic64Swapped: 536 m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig); 537 m_data.SetAddressByteSize(8); 538 can_parse = true; 539 break; 540 541 default: 542 break; 543 } 544 545 if (can_parse) 546 { 547 m_data.GetU32(&offset, &m_header.cputype, 6); 548 549 ArchSpec mach_arch(eArchTypeMachO, m_header.cputype, m_header.cpusubtype); 550 551 if (SetModulesArchitecture (mach_arch)) 552 { 553 const size_t header_and_lc_size = m_header.sizeofcmds + MachHeaderSizeFromMagic(m_header.magic); 554 if (m_data.GetByteSize() < header_and_lc_size) 555 { 556 DataBufferSP data_sp; 557 ProcessSP process_sp (m_process_wp.lock()); 558 if (process_sp) 559 { 560 data_sp = ReadMemory (process_sp, m_offset, header_and_lc_size); 561 } 562 else 563 { 564 // Read in all only the load command data from the file on disk 565 data_sp = m_file.ReadFileContents(m_offset, header_and_lc_size); 566 if (data_sp->GetByteSize() != header_and_lc_size) 567 return false; 568 } 569 if (data_sp) 570 m_data.SetData (data_sp); 571 } 572 } 573 return true; 574 } 575 else 576 { 577 memset(&m_header, 0, sizeof(struct mach_header)); 578 } 579 } 580 return false; 581 } 582 583 584 ByteOrder 585 ObjectFileMachO::GetByteOrder () const 586 { 587 return m_data.GetByteOrder (); 588 } 589 590 bool 591 ObjectFileMachO::IsExecutable() const 592 { 593 return m_header.filetype == HeaderFileTypeExecutable; 594 } 595 596 size_t 597 ObjectFileMachO::GetAddressByteSize () const 598 { 599 return m_data.GetAddressByteSize (); 600 } 601 602 AddressClass 603 ObjectFileMachO::GetAddressClass (lldb::addr_t file_addr) 604 { 605 Symtab *symtab = GetSymtab(); 606 if (symtab) 607 { 608 Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr); 609 if (symbol) 610 { 611 if (symbol->ValueIsAddress()) 612 { 613 SectionSP section_sp (symbol->GetAddress().GetSection()); 614 if (section_sp) 615 { 616 const SectionType section_type = section_sp->GetType(); 617 switch (section_type) 618 { 619 case eSectionTypeInvalid: return eAddressClassUnknown; 620 case eSectionTypeCode: 621 if (m_header.cputype == llvm::MachO::CPUTypeARM) 622 { 623 // For ARM we have a bit in the n_desc field of the symbol 624 // that tells us ARM/Thumb which is bit 0x0008. 625 if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB) 626 return eAddressClassCodeAlternateISA; 627 } 628 return eAddressClassCode; 629 630 case eSectionTypeContainer: return eAddressClassUnknown; 631 case eSectionTypeData: 632 case eSectionTypeDataCString: 633 case eSectionTypeDataCStringPointers: 634 case eSectionTypeDataSymbolAddress: 635 case eSectionTypeData4: 636 case eSectionTypeData8: 637 case eSectionTypeData16: 638 case eSectionTypeDataPointers: 639 case eSectionTypeZeroFill: 640 case eSectionTypeDataObjCMessageRefs: 641 case eSectionTypeDataObjCCFStrings: 642 return eAddressClassData; 643 case eSectionTypeDebug: 644 case eSectionTypeDWARFDebugAbbrev: 645 case eSectionTypeDWARFDebugAranges: 646 case eSectionTypeDWARFDebugFrame: 647 case eSectionTypeDWARFDebugInfo: 648 case eSectionTypeDWARFDebugLine: 649 case eSectionTypeDWARFDebugLoc: 650 case eSectionTypeDWARFDebugMacInfo: 651 case eSectionTypeDWARFDebugPubNames: 652 case eSectionTypeDWARFDebugPubTypes: 653 case eSectionTypeDWARFDebugRanges: 654 case eSectionTypeDWARFDebugStr: 655 case eSectionTypeDWARFAppleNames: 656 case eSectionTypeDWARFAppleTypes: 657 case eSectionTypeDWARFAppleNamespaces: 658 case eSectionTypeDWARFAppleObjC: 659 return eAddressClassDebug; 660 case eSectionTypeEHFrame: return eAddressClassRuntime; 661 case eSectionTypeOther: return eAddressClassUnknown; 662 } 663 } 664 } 665 666 const SymbolType symbol_type = symbol->GetType(); 667 switch (symbol_type) 668 { 669 case eSymbolTypeAny: return eAddressClassUnknown; 670 case eSymbolTypeAbsolute: return eAddressClassUnknown; 671 672 case eSymbolTypeCode: 673 case eSymbolTypeTrampoline: 674 if (m_header.cputype == llvm::MachO::CPUTypeARM) 675 { 676 // For ARM we have a bit in the n_desc field of the symbol 677 // that tells us ARM/Thumb which is bit 0x0008. 678 if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB) 679 return eAddressClassCodeAlternateISA; 680 } 681 return eAddressClassCode; 682 683 case eSymbolTypeData: return eAddressClassData; 684 case eSymbolTypeRuntime: return eAddressClassRuntime; 685 case eSymbolTypeException: return eAddressClassRuntime; 686 case eSymbolTypeSourceFile: return eAddressClassDebug; 687 case eSymbolTypeHeaderFile: return eAddressClassDebug; 688 case eSymbolTypeObjectFile: return eAddressClassDebug; 689 case eSymbolTypeCommonBlock: return eAddressClassDebug; 690 case eSymbolTypeBlock: return eAddressClassDebug; 691 case eSymbolTypeLocal: return eAddressClassData; 692 case eSymbolTypeParam: return eAddressClassData; 693 case eSymbolTypeVariable: return eAddressClassData; 694 case eSymbolTypeVariableType: return eAddressClassDebug; 695 case eSymbolTypeLineEntry: return eAddressClassDebug; 696 case eSymbolTypeLineHeader: return eAddressClassDebug; 697 case eSymbolTypeScopeBegin: return eAddressClassDebug; 698 case eSymbolTypeScopeEnd: return eAddressClassDebug; 699 case eSymbolTypeAdditional: return eAddressClassUnknown; 700 case eSymbolTypeCompiler: return eAddressClassDebug; 701 case eSymbolTypeInstrumentation:return eAddressClassDebug; 702 case eSymbolTypeUndefined: return eAddressClassUnknown; 703 case eSymbolTypeObjCClass: return eAddressClassRuntime; 704 case eSymbolTypeObjCMetaClass: return eAddressClassRuntime; 705 case eSymbolTypeObjCIVar: return eAddressClassRuntime; 706 } 707 } 708 } 709 return eAddressClassUnknown; 710 } 711 712 Symtab * 713 ObjectFileMachO::GetSymtab() 714 { 715 ModuleSP module_sp(GetModule()); 716 if (module_sp) 717 { 718 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 719 if (m_symtab_ap.get() == NULL) 720 { 721 m_symtab_ap.reset(new Symtab(this)); 722 Mutex::Locker symtab_locker (m_symtab_ap->GetMutex()); 723 ParseSymtab (true); 724 m_symtab_ap->Finalize (); 725 } 726 } 727 return m_symtab_ap.get(); 728 } 729 730 731 SectionList * 732 ObjectFileMachO::GetSectionList() 733 { 734 ModuleSP module_sp(GetModule()); 735 if (module_sp) 736 { 737 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 738 if (m_sections_ap.get() == NULL) 739 { 740 m_sections_ap.reset(new SectionList()); 741 ParseSections(); 742 } 743 } 744 return m_sections_ap.get(); 745 } 746 747 748 size_t 749 ObjectFileMachO::ParseSections () 750 { 751 lldb::user_id_t segID = 0; 752 lldb::user_id_t sectID = 0; 753 struct segment_command_64 load_cmd; 754 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic); 755 uint32_t i; 756 const bool is_core = GetType() == eTypeCoreFile; 757 //bool dump_sections = false; 758 ModuleSP module_sp (GetModule()); 759 for (i=0; i<m_header.ncmds; ++i) 760 { 761 const uint32_t load_cmd_offset = offset; 762 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL) 763 break; 764 765 if (load_cmd.cmd == LoadCommandSegment32 || load_cmd.cmd == LoadCommandSegment64) 766 { 767 if (m_data.GetU8(&offset, (uint8_t*)load_cmd.segname, 16)) 768 { 769 load_cmd.vmaddr = m_data.GetAddress(&offset); 770 load_cmd.vmsize = m_data.GetAddress(&offset); 771 load_cmd.fileoff = m_data.GetAddress(&offset); 772 load_cmd.filesize = m_data.GetAddress(&offset); 773 if (m_data.GetU32(&offset, &load_cmd.maxprot, 4)) 774 { 775 776 const bool segment_is_encrypted = (load_cmd.flags & SegmentCommandFlagBitProtectedVersion1) != 0; 777 778 // Keep a list of mach segments around in case we need to 779 // get at data that isn't stored in the abstracted Sections. 780 m_mach_segments.push_back (load_cmd); 781 782 ConstString segment_name (load_cmd.segname, std::min<int>(strlen(load_cmd.segname), sizeof(load_cmd.segname))); 783 // Use a segment ID of the segment index shifted left by 8 so they 784 // never conflict with any of the sections. 785 SectionSP segment_sp; 786 if (segment_name || is_core) 787 { 788 segment_sp.reset(new Section (module_sp, // Module to which this section belongs 789 ++segID << 8, // Section ID is the 1 based segment index shifted right by 8 bits as not to collide with any of the 256 section IDs that are possible 790 segment_name, // Name of this section 791 eSectionTypeContainer, // This section is a container of other sections. 792 load_cmd.vmaddr, // File VM address == addresses as they are found in the object file 793 load_cmd.vmsize, // VM size in bytes of this section 794 load_cmd.fileoff, // Offset to the data for this section in the file 795 load_cmd.filesize, // Size in bytes of this section as found in the the file 796 load_cmd.flags)); // Flags for this section 797 798 segment_sp->SetIsEncrypted (segment_is_encrypted); 799 m_sections_ap->AddSection(segment_sp); 800 } 801 802 struct section_64 sect64; 803 ::memset (§64, 0, sizeof(sect64)); 804 // Push a section into our mach sections for the section at 805 // index zero (NListSectionNoSection) if we don't have any 806 // mach sections yet... 807 if (m_mach_sections.empty()) 808 m_mach_sections.push_back(sect64); 809 uint32_t segment_sect_idx; 810 const lldb::user_id_t first_segment_sectID = sectID + 1; 811 812 813 const uint32_t num_u32s = load_cmd.cmd == LoadCommandSegment32 ? 7 : 8; 814 for (segment_sect_idx=0; segment_sect_idx<load_cmd.nsects; ++segment_sect_idx) 815 { 816 if (m_data.GetU8(&offset, (uint8_t*)sect64.sectname, sizeof(sect64.sectname)) == NULL) 817 break; 818 if (m_data.GetU8(&offset, (uint8_t*)sect64.segname, sizeof(sect64.segname)) == NULL) 819 break; 820 sect64.addr = m_data.GetAddress(&offset); 821 sect64.size = m_data.GetAddress(&offset); 822 823 if (m_data.GetU32(&offset, §64.offset, num_u32s) == NULL) 824 break; 825 826 // Keep a list of mach sections around in case we need to 827 // get at data that isn't stored in the abstracted Sections. 828 m_mach_sections.push_back (sect64); 829 830 ConstString section_name (sect64.sectname, std::min<size_t>(strlen(sect64.sectname), sizeof(sect64.sectname))); 831 if (!segment_name) 832 { 833 // We have a segment with no name so we need to conjure up 834 // segments that correspond to the section's segname if there 835 // isn't already such a section. If there is such a section, 836 // we resize the section so that it spans all sections. 837 // We also mark these sections as fake so address matches don't 838 // hit if they land in the gaps between the child sections. 839 segment_name.SetTrimmedCStringWithLength(sect64.segname, sizeof(sect64.segname)); 840 segment_sp = m_sections_ap->FindSectionByName (segment_name); 841 if (segment_sp.get()) 842 { 843 Section *segment = segment_sp.get(); 844 // Grow the section size as needed. 845 const lldb::addr_t sect64_min_addr = sect64.addr; 846 const lldb::addr_t sect64_max_addr = sect64_min_addr + sect64.size; 847 const lldb::addr_t curr_seg_byte_size = segment->GetByteSize(); 848 const lldb::addr_t curr_seg_min_addr = segment->GetFileAddress(); 849 const lldb::addr_t curr_seg_max_addr = curr_seg_min_addr + curr_seg_byte_size; 850 if (sect64_min_addr >= curr_seg_min_addr) 851 { 852 const lldb::addr_t new_seg_byte_size = sect64_max_addr - curr_seg_min_addr; 853 // Only grow the section size if needed 854 if (new_seg_byte_size > curr_seg_byte_size) 855 segment->SetByteSize (new_seg_byte_size); 856 } 857 else 858 { 859 // We need to change the base address of the segment and 860 // adjust the child section offsets for all existing children. 861 const lldb::addr_t slide_amount = sect64_min_addr - curr_seg_min_addr; 862 segment->Slide(slide_amount, false); 863 segment->GetChildren().Slide (-slide_amount, false); 864 segment->SetByteSize (curr_seg_max_addr - sect64_min_addr); 865 } 866 867 // Grow the section size as needed. 868 if (sect64.offset) 869 { 870 const lldb::addr_t segment_min_file_offset = segment->GetFileOffset(); 871 const lldb::addr_t segment_max_file_offset = segment_min_file_offset + segment->GetFileSize(); 872 873 const lldb::addr_t section_min_file_offset = sect64.offset; 874 const lldb::addr_t section_max_file_offset = section_min_file_offset + sect64.size; 875 const lldb::addr_t new_file_offset = std::min (section_min_file_offset, segment_min_file_offset); 876 const lldb::addr_t new_file_size = std::max (section_max_file_offset, segment_max_file_offset) - new_file_offset; 877 segment->SetFileOffset (new_file_offset); 878 segment->SetFileSize (new_file_size); 879 } 880 } 881 else 882 { 883 // Create a fake section for the section's named segment 884 segment_sp.reset(new Section (segment_sp, // Parent section 885 module_sp, // Module to which this section belongs 886 ++segID << 8, // Section ID is the 1 based segment index shifted right by 8 bits as not to collide with any of the 256 section IDs that are possible 887 segment_name, // Name of this section 888 eSectionTypeContainer, // This section is a container of other sections. 889 sect64.addr, // File VM address == addresses as they are found in the object file 890 sect64.size, // VM size in bytes of this section 891 sect64.offset, // Offset to the data for this section in the file 892 sect64.offset ? sect64.size : 0, // Size in bytes of this section as found in the the file 893 load_cmd.flags)); // Flags for this section 894 segment_sp->SetIsFake(true); 895 m_sections_ap->AddSection(segment_sp); 896 segment_sp->SetIsEncrypted (segment_is_encrypted); 897 } 898 } 899 assert (segment_sp.get()); 900 901 uint32_t mach_sect_type = sect64.flags & SectionFlagMaskSectionType; 902 static ConstString g_sect_name_objc_data ("__objc_data"); 903 static ConstString g_sect_name_objc_msgrefs ("__objc_msgrefs"); 904 static ConstString g_sect_name_objc_selrefs ("__objc_selrefs"); 905 static ConstString g_sect_name_objc_classrefs ("__objc_classrefs"); 906 static ConstString g_sect_name_objc_superrefs ("__objc_superrefs"); 907 static ConstString g_sect_name_objc_const ("__objc_const"); 908 static ConstString g_sect_name_objc_classlist ("__objc_classlist"); 909 static ConstString g_sect_name_cfstring ("__cfstring"); 910 911 static ConstString g_sect_name_dwarf_debug_abbrev ("__debug_abbrev"); 912 static ConstString g_sect_name_dwarf_debug_aranges ("__debug_aranges"); 913 static ConstString g_sect_name_dwarf_debug_frame ("__debug_frame"); 914 static ConstString g_sect_name_dwarf_debug_info ("__debug_info"); 915 static ConstString g_sect_name_dwarf_debug_line ("__debug_line"); 916 static ConstString g_sect_name_dwarf_debug_loc ("__debug_loc"); 917 static ConstString g_sect_name_dwarf_debug_macinfo ("__debug_macinfo"); 918 static ConstString g_sect_name_dwarf_debug_pubnames ("__debug_pubnames"); 919 static ConstString g_sect_name_dwarf_debug_pubtypes ("__debug_pubtypes"); 920 static ConstString g_sect_name_dwarf_debug_ranges ("__debug_ranges"); 921 static ConstString g_sect_name_dwarf_debug_str ("__debug_str"); 922 static ConstString g_sect_name_dwarf_apple_names ("__apple_names"); 923 static ConstString g_sect_name_dwarf_apple_types ("__apple_types"); 924 static ConstString g_sect_name_dwarf_apple_namespaces ("__apple_namespac"); 925 static ConstString g_sect_name_dwarf_apple_objc ("__apple_objc"); 926 static ConstString g_sect_name_eh_frame ("__eh_frame"); 927 static ConstString g_sect_name_DATA ("__DATA"); 928 static ConstString g_sect_name_TEXT ("__TEXT"); 929 930 SectionType sect_type = eSectionTypeOther; 931 932 if (section_name == g_sect_name_dwarf_debug_abbrev) 933 sect_type = eSectionTypeDWARFDebugAbbrev; 934 else if (section_name == g_sect_name_dwarf_debug_aranges) 935 sect_type = eSectionTypeDWARFDebugAranges; 936 else if (section_name == g_sect_name_dwarf_debug_frame) 937 sect_type = eSectionTypeDWARFDebugFrame; 938 else if (section_name == g_sect_name_dwarf_debug_info) 939 sect_type = eSectionTypeDWARFDebugInfo; 940 else if (section_name == g_sect_name_dwarf_debug_line) 941 sect_type = eSectionTypeDWARFDebugLine; 942 else if (section_name == g_sect_name_dwarf_debug_loc) 943 sect_type = eSectionTypeDWARFDebugLoc; 944 else if (section_name == g_sect_name_dwarf_debug_macinfo) 945 sect_type = eSectionTypeDWARFDebugMacInfo; 946 else if (section_name == g_sect_name_dwarf_debug_pubnames) 947 sect_type = eSectionTypeDWARFDebugPubNames; 948 else if (section_name == g_sect_name_dwarf_debug_pubtypes) 949 sect_type = eSectionTypeDWARFDebugPubTypes; 950 else if (section_name == g_sect_name_dwarf_debug_ranges) 951 sect_type = eSectionTypeDWARFDebugRanges; 952 else if (section_name == g_sect_name_dwarf_debug_str) 953 sect_type = eSectionTypeDWARFDebugStr; 954 else if (section_name == g_sect_name_dwarf_apple_names) 955 sect_type = eSectionTypeDWARFAppleNames; 956 else if (section_name == g_sect_name_dwarf_apple_types) 957 sect_type = eSectionTypeDWARFAppleTypes; 958 else if (section_name == g_sect_name_dwarf_apple_namespaces) 959 sect_type = eSectionTypeDWARFAppleNamespaces; 960 else if (section_name == g_sect_name_dwarf_apple_objc) 961 sect_type = eSectionTypeDWARFAppleObjC; 962 else if (section_name == g_sect_name_objc_selrefs) 963 sect_type = eSectionTypeDataCStringPointers; 964 else if (section_name == g_sect_name_objc_msgrefs) 965 sect_type = eSectionTypeDataObjCMessageRefs; 966 else if (section_name == g_sect_name_eh_frame) 967 sect_type = eSectionTypeEHFrame; 968 else if (section_name == g_sect_name_cfstring) 969 sect_type = eSectionTypeDataObjCCFStrings; 970 else if (section_name == g_sect_name_objc_data || 971 section_name == g_sect_name_objc_classrefs || 972 section_name == g_sect_name_objc_superrefs || 973 section_name == g_sect_name_objc_const || 974 section_name == g_sect_name_objc_classlist) 975 { 976 sect_type = eSectionTypeDataPointers; 977 } 978 979 if (sect_type == eSectionTypeOther) 980 { 981 switch (mach_sect_type) 982 { 983 // TODO: categorize sections by other flags for regular sections 984 case SectionTypeRegular: 985 if (segment_sp->GetName() == g_sect_name_TEXT) 986 sect_type = eSectionTypeCode; 987 else if (segment_sp->GetName() == g_sect_name_DATA) 988 sect_type = eSectionTypeData; 989 else 990 sect_type = eSectionTypeOther; 991 break; 992 case SectionTypeZeroFill: sect_type = eSectionTypeZeroFill; break; 993 case SectionTypeCStringLiterals: sect_type = eSectionTypeDataCString; break; // section with only literal C strings 994 case SectionType4ByteLiterals: sect_type = eSectionTypeData4; break; // section with only 4 byte literals 995 case SectionType8ByteLiterals: sect_type = eSectionTypeData8; break; // section with only 8 byte literals 996 case SectionTypeLiteralPointers: sect_type = eSectionTypeDataPointers; break; // section with only pointers to literals 997 case SectionTypeNonLazySymbolPointers: sect_type = eSectionTypeDataPointers; break; // section with only non-lazy symbol pointers 998 case SectionTypeLazySymbolPointers: sect_type = eSectionTypeDataPointers; break; // section with only lazy symbol pointers 999 case SectionTypeSymbolStubs: sect_type = eSectionTypeCode; break; // section with only symbol stubs, byte size of stub in the reserved2 field 1000 case SectionTypeModuleInitFunctionPointers: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for initialization 1001 case SectionTypeModuleTermFunctionPointers: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for termination 1002 case SectionTypeCoalesced: sect_type = eSectionTypeOther; break; 1003 case SectionTypeZeroFillLarge: sect_type = eSectionTypeZeroFill; break; 1004 case SectionTypeInterposing: sect_type = eSectionTypeCode; break; // section with only pairs of function pointers for interposing 1005 case SectionType16ByteLiterals: sect_type = eSectionTypeData16; break; // section with only 16 byte literals 1006 case SectionTypeDTraceObjectFormat: sect_type = eSectionTypeDebug; break; 1007 case SectionTypeLazyDylibSymbolPointers: sect_type = eSectionTypeDataPointers; break; 1008 default: break; 1009 } 1010 } 1011 1012 SectionSP section_sp(new Section (segment_sp, 1013 module_sp, 1014 ++sectID, 1015 section_name, 1016 sect_type, 1017 sect64.addr - segment_sp->GetFileAddress(), 1018 sect64.size, 1019 sect64.offset, 1020 sect64.offset == 0 ? 0 : sect64.size, 1021 sect64.flags)); 1022 // Set the section to be encrypted to match the segment 1023 section_sp->SetIsEncrypted (segment_is_encrypted); 1024 1025 segment_sp->GetChildren().AddSection(section_sp); 1026 1027 if (segment_sp->IsFake()) 1028 { 1029 segment_sp.reset(); 1030 segment_name.Clear(); 1031 } 1032 } 1033 if (segment_sp && m_header.filetype == HeaderFileTypeDSYM) 1034 { 1035 if (first_segment_sectID <= sectID) 1036 { 1037 lldb::user_id_t sect_uid; 1038 for (sect_uid = first_segment_sectID; sect_uid <= sectID; ++sect_uid) 1039 { 1040 SectionSP curr_section_sp(segment_sp->GetChildren().FindSectionByID (sect_uid)); 1041 SectionSP next_section_sp; 1042 if (sect_uid + 1 <= sectID) 1043 next_section_sp = segment_sp->GetChildren().FindSectionByID (sect_uid+1); 1044 1045 if (curr_section_sp.get()) 1046 { 1047 if (curr_section_sp->GetByteSize() == 0) 1048 { 1049 if (next_section_sp.get() != NULL) 1050 curr_section_sp->SetByteSize ( next_section_sp->GetFileAddress() - curr_section_sp->GetFileAddress() ); 1051 else 1052 curr_section_sp->SetByteSize ( load_cmd.vmsize ); 1053 } 1054 } 1055 } 1056 } 1057 } 1058 } 1059 } 1060 } 1061 else if (load_cmd.cmd == LoadCommandDynamicSymtabInfo) 1062 { 1063 m_dysymtab.cmd = load_cmd.cmd; 1064 m_dysymtab.cmdsize = load_cmd.cmdsize; 1065 m_data.GetU32 (&offset, &m_dysymtab.ilocalsym, (sizeof(m_dysymtab) / sizeof(uint32_t)) - 2); 1066 } 1067 1068 offset = load_cmd_offset + load_cmd.cmdsize; 1069 } 1070 // if (dump_sections) 1071 // { 1072 // StreamFile s(stdout); 1073 // m_sections_ap->Dump(&s, true); 1074 // } 1075 return sectID; // Return the number of sections we registered with the module 1076 } 1077 1078 class MachSymtabSectionInfo 1079 { 1080 public: 1081 1082 MachSymtabSectionInfo (SectionList *section_list) : 1083 m_section_list (section_list), 1084 m_section_infos() 1085 { 1086 // Get the number of sections down to a depth of 1 to include 1087 // all segments and their sections, but no other sections that 1088 // may be added for debug map or 1089 m_section_infos.resize(section_list->GetNumSections(1)); 1090 } 1091 1092 1093 SectionSP 1094 GetSection (uint8_t n_sect, addr_t file_addr) 1095 { 1096 if (n_sect == 0) 1097 return SectionSP(); 1098 if (n_sect < m_section_infos.size()) 1099 { 1100 if (!m_section_infos[n_sect].section_sp) 1101 { 1102 SectionSP section_sp (m_section_list->FindSectionByID (n_sect)); 1103 m_section_infos[n_sect].section_sp = section_sp; 1104 if (section_sp != NULL) 1105 { 1106 m_section_infos[n_sect].vm_range.SetBaseAddress (section_sp->GetFileAddress()); 1107 m_section_infos[n_sect].vm_range.SetByteSize (section_sp->GetByteSize()); 1108 } 1109 else 1110 { 1111 Host::SystemLog (Host::eSystemLogError, "error: unable to find section for section %u\n", n_sect); 1112 } 1113 } 1114 if (m_section_infos[n_sect].vm_range.Contains(file_addr)) 1115 { 1116 // Symbol is in section. 1117 return m_section_infos[n_sect].section_sp; 1118 } 1119 else if (m_section_infos[n_sect].vm_range.GetByteSize () == 0 && 1120 m_section_infos[n_sect].vm_range.GetBaseAddress() == file_addr) 1121 { 1122 // Symbol is in section with zero size, but has the same start 1123 // address as the section. This can happen with linker symbols 1124 // (symbols that start with the letter 'l' or 'L'. 1125 return m_section_infos[n_sect].section_sp; 1126 } 1127 } 1128 return m_section_list->FindSectionContainingFileAddress(file_addr); 1129 } 1130 1131 protected: 1132 struct SectionInfo 1133 { 1134 SectionInfo () : 1135 vm_range(), 1136 section_sp () 1137 { 1138 } 1139 1140 VMRange vm_range; 1141 SectionSP section_sp; 1142 }; 1143 SectionList *m_section_list; 1144 std::vector<SectionInfo> m_section_infos; 1145 }; 1146 1147 1148 1149 size_t 1150 ObjectFileMachO::ParseSymtab (bool minimize) 1151 { 1152 Timer scoped_timer(__PRETTY_FUNCTION__, 1153 "ObjectFileMachO::ParseSymtab () module = %s", 1154 m_file.GetFilename().AsCString("")); 1155 ModuleSP module_sp (GetModule()); 1156 if (!module_sp) 1157 return 0; 1158 1159 struct symtab_command symtab_load_command = { 0, 0, 0, 0, 0, 0 }; 1160 struct linkedit_data_command function_starts_load_command = { 0, 0, 0, 0 }; 1161 typedef AddressDataArray<lldb::addr_t, bool, 100> FunctionStarts; 1162 FunctionStarts function_starts; 1163 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic); 1164 uint32_t i; 1165 1166 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS)); 1167 1168 for (i=0; i<m_header.ncmds; ++i) 1169 { 1170 const uint32_t cmd_offset = offset; 1171 // Read in the load command and load command size 1172 struct load_command lc; 1173 if (m_data.GetU32(&offset, &lc, 2) == NULL) 1174 break; 1175 // Watch for the symbol table load command 1176 switch (lc.cmd) 1177 { 1178 case LoadCommandSymtab: 1179 symtab_load_command.cmd = lc.cmd; 1180 symtab_load_command.cmdsize = lc.cmdsize; 1181 // Read in the rest of the symtab load command 1182 if (m_data.GetU32(&offset, &symtab_load_command.symoff, 4) == 0) // fill in symoff, nsyms, stroff, strsize fields 1183 return 0; 1184 if (symtab_load_command.symoff == 0) 1185 { 1186 if (log) 1187 module_sp->LogMessage(log.get(), "LC_SYMTAB.symoff == 0"); 1188 return 0; 1189 } 1190 1191 if (symtab_load_command.stroff == 0) 1192 { 1193 if (log) 1194 module_sp->LogMessage(log.get(), "LC_SYMTAB.stroff == 0"); 1195 return 0; 1196 } 1197 1198 if (symtab_load_command.nsyms == 0) 1199 { 1200 if (log) 1201 module_sp->LogMessage(log.get(), "LC_SYMTAB.nsyms == 0"); 1202 return 0; 1203 } 1204 1205 if (symtab_load_command.strsize == 0) 1206 { 1207 if (log) 1208 module_sp->LogMessage(log.get(), "LC_SYMTAB.strsize == 0"); 1209 return 0; 1210 } 1211 break; 1212 1213 case LoadCommandFunctionStarts: 1214 function_starts_load_command.cmd = lc.cmd; 1215 function_starts_load_command.cmdsize = lc.cmdsize; 1216 if (m_data.GetU32(&offset, &function_starts_load_command.dataoff, 2) == NULL) // fill in symoff, nsyms, stroff, strsize fields 1217 bzero (&function_starts_load_command, sizeof(function_starts_load_command)); 1218 break; 1219 1220 default: 1221 break; 1222 } 1223 offset = cmd_offset + lc.cmdsize; 1224 } 1225 1226 if (symtab_load_command.cmd) 1227 { 1228 Symtab *symtab = m_symtab_ap.get(); 1229 SectionList *section_list = GetSectionList(); 1230 if (section_list == NULL) 1231 return 0; 1232 1233 ProcessSP process_sp (m_process_wp.lock()); 1234 1235 const size_t addr_byte_size = m_data.GetAddressByteSize(); 1236 bool bit_width_32 = addr_byte_size == 4; 1237 const size_t nlist_byte_size = bit_width_32 ? sizeof(struct nlist) : sizeof(struct nlist_64); 1238 1239 DataExtractor nlist_data (NULL, 0, m_data.GetByteOrder(), m_data.GetAddressByteSize()); 1240 DataExtractor strtab_data (NULL, 0, m_data.GetByteOrder(), m_data.GetAddressByteSize()); 1241 DataExtractor function_starts_data (NULL, 0, m_data.GetByteOrder(), m_data.GetAddressByteSize()); 1242 1243 const addr_t nlist_data_byte_size = symtab_load_command.nsyms * nlist_byte_size; 1244 const addr_t strtab_data_byte_size = symtab_load_command.strsize; 1245 if (process_sp) 1246 { 1247 Target &target = process_sp->GetTarget(); 1248 SectionSP linkedit_section_sp(section_list->FindSectionByName(GetSegmentNameLINKEDIT())); 1249 // Reading mach file from memory in a process or core file... 1250 1251 if (linkedit_section_sp) 1252 { 1253 const addr_t linkedit_load_addr = linkedit_section_sp->GetLoadBaseAddress(&target); 1254 const addr_t linkedit_file_offset = linkedit_section_sp->GetFileOffset(); 1255 const addr_t symoff_addr = linkedit_load_addr + symtab_load_command.symoff - linkedit_file_offset; 1256 const addr_t stroff_addr = linkedit_load_addr + symtab_load_command.stroff - linkedit_file_offset; 1257 1258 bool data_was_read = false; 1259 1260 #if defined (__APPLE__) && defined (__arm__) 1261 if (m_header.flags & 0x80000000u) 1262 { 1263 // This mach-o memory file is in the dyld shared cache. If this 1264 // program is not remote and this is iOS, then this process will 1265 // share the same shared cache as the process we are debugging and 1266 // we can read the entire __LINKEDIT from the address space in this 1267 // process. This is a needed optimization that is used for local iOS 1268 // debugging only since all shared libraries in the shared cache do 1269 // not have corresponding files that exist in the file system of the 1270 // device. They have been combined into a single file. This means we 1271 // always have to load these files from memory. All of the symbol and 1272 // string tables from all of the __LINKEDIT sections from the shared 1273 // libraries in the shared cache have been merged into a single large 1274 // symbol and string table. Reading all of this symbol and string table 1275 // data across can slow down debug launch times, so we optimize this by 1276 // reading the memory for the __LINKEDIT section from this process. 1277 PlatformSP platform_sp (target.GetPlatform()); 1278 if (platform_sp && platform_sp->IsHost()) 1279 { 1280 data_was_read = true; 1281 nlist_data.SetData((void *)symoff_addr, nlist_data_byte_size, eByteOrderLittle); 1282 strtab_data.SetData((void *)stroff_addr, strtab_data_byte_size, eByteOrderLittle); 1283 if (function_starts_load_command.cmd) 1284 { 1285 const addr_t func_start_addr = linkedit_load_addr + function_starts_load_command.dataoff - linkedit_file_offset; 1286 function_starts_data.SetData ((void *)func_start_addr, function_starts_load_command.datasize, eByteOrderLittle); 1287 } 1288 } 1289 } 1290 #endif 1291 1292 if (!data_was_read) 1293 { 1294 DataBufferSP nlist_data_sp (ReadMemory (process_sp, symoff_addr, nlist_data_byte_size)); 1295 if (nlist_data_sp) 1296 nlist_data.SetData (nlist_data_sp, 0, nlist_data_sp->GetByteSize()); 1297 DataBufferSP strtab_data_sp (ReadMemory (process_sp, stroff_addr, strtab_data_byte_size)); 1298 if (strtab_data_sp) 1299 strtab_data.SetData (strtab_data_sp, 0, strtab_data_sp->GetByteSize()); 1300 if (function_starts_load_command.cmd) 1301 { 1302 const addr_t func_start_addr = linkedit_load_addr + function_starts_load_command.dataoff - linkedit_file_offset; 1303 DataBufferSP func_start_data_sp (ReadMemory (process_sp, func_start_addr, function_starts_load_command.datasize)); 1304 if (func_start_data_sp) 1305 function_starts_data.SetData (func_start_data_sp, 0, func_start_data_sp->GetByteSize()); 1306 } 1307 } 1308 } 1309 } 1310 else 1311 { 1312 nlist_data.SetData (m_data, 1313 symtab_load_command.symoff, 1314 nlist_data_byte_size); 1315 strtab_data.SetData (m_data, 1316 symtab_load_command.stroff, 1317 strtab_data_byte_size); 1318 if (function_starts_load_command.cmd) 1319 { 1320 function_starts_data.SetData (m_data, 1321 function_starts_load_command.dataoff, 1322 function_starts_load_command.datasize); 1323 } 1324 } 1325 1326 if (nlist_data.GetByteSize() == 0) 1327 { 1328 if (log) 1329 module_sp->LogMessage(log.get(), "failed to read nlist data"); 1330 return 0; 1331 } 1332 1333 1334 if (strtab_data.GetByteSize() == 0) 1335 { 1336 if (log) 1337 module_sp->LogMessage(log.get(), "failed to read strtab data"); 1338 return 0; 1339 } 1340 1341 const ConstString &g_segment_name_TEXT = GetSegmentNameTEXT(); 1342 const ConstString &g_segment_name_DATA = GetSegmentNameDATA(); 1343 const ConstString &g_segment_name_OBJC = GetSegmentNameOBJC(); 1344 const ConstString &g_section_name_eh_frame = GetSectionNameEHFrame(); 1345 SectionSP text_section_sp(section_list->FindSectionByName(g_segment_name_TEXT)); 1346 SectionSP data_section_sp(section_list->FindSectionByName(g_segment_name_DATA)); 1347 SectionSP objc_section_sp(section_list->FindSectionByName(g_segment_name_OBJC)); 1348 SectionSP eh_frame_section_sp; 1349 if (text_section_sp.get()) 1350 eh_frame_section_sp = text_section_sp->GetChildren().FindSectionByName (g_section_name_eh_frame); 1351 else 1352 eh_frame_section_sp = section_list->FindSectionByName (g_section_name_eh_frame); 1353 1354 const bool is_arm = (m_header.cputype == llvm::MachO::CPUTypeARM); 1355 if (text_section_sp && function_starts_data.GetByteSize()) 1356 { 1357 FunctionStarts::Entry function_start_entry; 1358 function_start_entry.data = false; 1359 uint32_t function_start_offset = 0; 1360 function_start_entry.addr = text_section_sp->GetFileAddress(); 1361 uint64_t delta; 1362 while ((delta = function_starts_data.GetULEB128(&function_start_offset)) > 0) 1363 { 1364 // Now append the current entry 1365 function_start_entry.addr += delta; 1366 function_starts.Append(function_start_entry); 1367 } 1368 } 1369 1370 const uint32_t function_starts_count = function_starts.GetSize(); 1371 1372 uint8_t TEXT_eh_frame_sectID = eh_frame_section_sp.get() ? eh_frame_section_sp->GetID() : NListSectionNoSection; 1373 1374 uint32_t nlist_data_offset = 0; 1375 1376 uint32_t N_SO_index = UINT32_MAX; 1377 1378 MachSymtabSectionInfo section_info (section_list); 1379 std::vector<uint32_t> N_FUN_indexes; 1380 std::vector<uint32_t> N_NSYM_indexes; 1381 std::vector<uint32_t> N_INCL_indexes; 1382 std::vector<uint32_t> N_BRAC_indexes; 1383 std::vector<uint32_t> N_COMM_indexes; 1384 typedef std::map <uint64_t, uint32_t> ValueToSymbolIndexMap; 1385 typedef std::map <uint32_t, uint32_t> NListIndexToSymbolIndexMap; 1386 ValueToSymbolIndexMap N_FUN_addr_to_sym_idx; 1387 ValueToSymbolIndexMap N_STSYM_addr_to_sym_idx; 1388 // Any symbols that get merged into another will get an entry 1389 // in this map so we know 1390 NListIndexToSymbolIndexMap m_nlist_idx_to_sym_idx; 1391 uint32_t nlist_idx = 0; 1392 Symbol *symbol_ptr = NULL; 1393 1394 uint32_t sym_idx = 0; 1395 Symbol *sym = symtab->Resize (symtab_load_command.nsyms + m_dysymtab.nindirectsyms); 1396 uint32_t num_syms = symtab->GetNumSymbols(); 1397 1398 //symtab->Reserve (symtab_load_command.nsyms + m_dysymtab.nindirectsyms); 1399 for (nlist_idx = 0; nlist_idx < symtab_load_command.nsyms; ++nlist_idx) 1400 { 1401 struct nlist_64 nlist; 1402 if (!nlist_data.ValidOffsetForDataOfSize(nlist_data_offset, nlist_byte_size)) 1403 break; 1404 1405 nlist.n_strx = nlist_data.GetU32_unchecked(&nlist_data_offset); 1406 nlist.n_type = nlist_data.GetU8_unchecked (&nlist_data_offset); 1407 nlist.n_sect = nlist_data.GetU8_unchecked (&nlist_data_offset); 1408 nlist.n_desc = nlist_data.GetU16_unchecked (&nlist_data_offset); 1409 nlist.n_value = nlist_data.GetAddress_unchecked (&nlist_data_offset); 1410 1411 SymbolType type = eSymbolTypeInvalid; 1412 const char *symbol_name = strtab_data.PeekCStr(nlist.n_strx); 1413 if (symbol_name == NULL) 1414 { 1415 // No symbol should be NULL, even the symbols with no 1416 // string values should have an offset zero which points 1417 // to an empty C-string 1418 Host::SystemLog (Host::eSystemLogError, 1419 "error: symbol[%u] has invalid string table offset 0x%x in %s/%s, ignoring symbol\n", 1420 nlist_idx, 1421 nlist.n_strx, 1422 module_sp->GetFileSpec().GetDirectory().GetCString(), 1423 module_sp->GetFileSpec().GetFilename().GetCString()); 1424 continue; 1425 } 1426 const char *symbol_name_non_abi_mangled = NULL; 1427 1428 if (symbol_name[0] == '\0') 1429 symbol_name = NULL; 1430 SectionSP symbol_section; 1431 uint32_t symbol_byte_size = 0; 1432 bool add_nlist = true; 1433 bool is_debug = ((nlist.n_type & NlistMaskStab) != 0); 1434 1435 assert (sym_idx < num_syms); 1436 1437 sym[sym_idx].SetDebug (is_debug); 1438 1439 if (is_debug) 1440 { 1441 switch (nlist.n_type) 1442 { 1443 case StabGlobalSymbol: 1444 // N_GSYM -- global symbol: name,,NO_SECT,type,0 1445 // Sometimes the N_GSYM value contains the address. 1446 1447 // FIXME: In the .o files, we have a GSYM and a debug symbol for all the ObjC data. They 1448 // have the same address, but we want to ensure that we always find only the real symbol, 1449 // 'cause we don't currently correctly attribute the GSYM one to the ObjCClass/Ivar/MetaClass 1450 // symbol type. This is a temporary hack to make sure the ObjectiveC symbols get treated 1451 // correctly. To do this right, we should coalesce all the GSYM & global symbols that have the 1452 // same address. 1453 1454 if (symbol_name && symbol_name[0] == '_' && symbol_name[1] == 'O' 1455 && (strncmp (symbol_name, "_OBJC_IVAR_$_", strlen ("_OBJC_IVAR_$_")) == 0 1456 || strncmp (symbol_name, "_OBJC_CLASS_$_", strlen ("_OBJC_CLASS_$_")) == 0 1457 || strncmp (symbol_name, "_OBJC_METACLASS_$_", strlen ("_OBJC_METACLASS_$_")) == 0)) 1458 add_nlist = false; 1459 else 1460 { 1461 sym[sym_idx].SetExternal(true); 1462 if (nlist.n_value != 0) 1463 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1464 type = eSymbolTypeData; 1465 } 1466 break; 1467 1468 case StabFunctionName: 1469 // N_FNAME -- procedure name (f77 kludge): name,,NO_SECT,0,0 1470 type = eSymbolTypeCompiler; 1471 break; 1472 1473 case StabFunction: 1474 // N_FUN -- procedure: name,,n_sect,linenumber,address 1475 if (symbol_name) 1476 { 1477 type = eSymbolTypeCode; 1478 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1479 1480 N_FUN_addr_to_sym_idx[nlist.n_value] = sym_idx; 1481 // We use the current number of symbols in the symbol table in lieu of 1482 // using nlist_idx in case we ever start trimming entries out 1483 N_FUN_indexes.push_back(sym_idx); 1484 } 1485 else 1486 { 1487 type = eSymbolTypeCompiler; 1488 1489 if ( !N_FUN_indexes.empty() ) 1490 { 1491 // Copy the size of the function into the original STAB entry so we don't have 1492 // to hunt for it later 1493 symtab->SymbolAtIndex(N_FUN_indexes.back())->SetByteSize(nlist.n_value); 1494 N_FUN_indexes.pop_back(); 1495 // We don't really need the end function STAB as it contains the size which 1496 // we already placed with the original symbol, so don't add it if we want a 1497 // minimal symbol table 1498 if (minimize) 1499 add_nlist = false; 1500 } 1501 } 1502 break; 1503 1504 case StabStaticSymbol: 1505 // N_STSYM -- static symbol: name,,n_sect,type,address 1506 N_STSYM_addr_to_sym_idx[nlist.n_value] = sym_idx; 1507 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1508 type = eSymbolTypeData; 1509 break; 1510 1511 case StabLocalCommon: 1512 // N_LCSYM -- .lcomm symbol: name,,n_sect,type,address 1513 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1514 type = eSymbolTypeCommonBlock; 1515 break; 1516 1517 case StabBeginSymbol: 1518 // N_BNSYM 1519 // We use the current number of symbols in the symbol table in lieu of 1520 // using nlist_idx in case we ever start trimming entries out 1521 if (minimize) 1522 { 1523 // Skip these if we want minimal symbol tables 1524 add_nlist = false; 1525 } 1526 else 1527 { 1528 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1529 N_NSYM_indexes.push_back(sym_idx); 1530 type = eSymbolTypeScopeBegin; 1531 } 1532 break; 1533 1534 case StabEndSymbol: 1535 // N_ENSYM 1536 // Set the size of the N_BNSYM to the terminating index of this N_ENSYM 1537 // so that we can always skip the entire symbol if we need to navigate 1538 // more quickly at the source level when parsing STABS 1539 if (minimize) 1540 { 1541 // Skip these if we want minimal symbol tables 1542 add_nlist = false; 1543 } 1544 else 1545 { 1546 if ( !N_NSYM_indexes.empty() ) 1547 { 1548 symbol_ptr = symtab->SymbolAtIndex(N_NSYM_indexes.back()); 1549 symbol_ptr->SetByteSize(sym_idx + 1); 1550 symbol_ptr->SetSizeIsSibling(true); 1551 N_NSYM_indexes.pop_back(); 1552 } 1553 type = eSymbolTypeScopeEnd; 1554 } 1555 break; 1556 1557 1558 case StabSourceFileOptions: 1559 // N_OPT - emitted with gcc2_compiled and in gcc source 1560 type = eSymbolTypeCompiler; 1561 break; 1562 1563 case StabRegisterSymbol: 1564 // N_RSYM - register sym: name,,NO_SECT,type,register 1565 type = eSymbolTypeVariable; 1566 break; 1567 1568 case StabSourceLine: 1569 // N_SLINE - src line: 0,,n_sect,linenumber,address 1570 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1571 type = eSymbolTypeLineEntry; 1572 break; 1573 1574 case StabStructureType: 1575 // N_SSYM - structure elt: name,,NO_SECT,type,struct_offset 1576 type = eSymbolTypeVariableType; 1577 break; 1578 1579 case StabSourceFileName: 1580 // N_SO - source file name 1581 type = eSymbolTypeSourceFile; 1582 if (symbol_name == NULL) 1583 { 1584 if (minimize) 1585 add_nlist = false; 1586 if (N_SO_index != UINT32_MAX) 1587 { 1588 // Set the size of the N_SO to the terminating index of this N_SO 1589 // so that we can always skip the entire N_SO if we need to navigate 1590 // more quickly at the source level when parsing STABS 1591 symbol_ptr = symtab->SymbolAtIndex(N_SO_index); 1592 symbol_ptr->SetByteSize(sym_idx + (minimize ? 0 : 1)); 1593 symbol_ptr->SetSizeIsSibling(true); 1594 } 1595 N_NSYM_indexes.clear(); 1596 N_INCL_indexes.clear(); 1597 N_BRAC_indexes.clear(); 1598 N_COMM_indexes.clear(); 1599 N_FUN_indexes.clear(); 1600 N_SO_index = UINT32_MAX; 1601 } 1602 else 1603 { 1604 // We use the current number of symbols in the symbol table in lieu of 1605 // using nlist_idx in case we ever start trimming entries out 1606 if (symbol_name[0] == '/') 1607 N_SO_index = sym_idx; 1608 else if (minimize && (N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms)) 1609 { 1610 const char *so_path = sym[sym_idx - 1].GetMangled().GetDemangledName().AsCString(); 1611 if (so_path && so_path[0]) 1612 { 1613 std::string full_so_path (so_path); 1614 if (*full_so_path.rbegin() != '/') 1615 full_so_path += '/'; 1616 full_so_path += symbol_name; 1617 sym[sym_idx - 1].GetMangled().SetValue(full_so_path.c_str(), false); 1618 add_nlist = false; 1619 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1; 1620 } 1621 } 1622 } 1623 1624 break; 1625 1626 case StabObjectFileName: 1627 // N_OSO - object file name: name,,0,0,st_mtime 1628 type = eSymbolTypeObjectFile; 1629 break; 1630 1631 case StabLocalSymbol: 1632 // N_LSYM - local sym: name,,NO_SECT,type,offset 1633 type = eSymbolTypeLocal; 1634 break; 1635 1636 //---------------------------------------------------------------------- 1637 // INCL scopes 1638 //---------------------------------------------------------------------- 1639 case StabBeginIncludeFileName: 1640 // N_BINCL - include file beginning: name,,NO_SECT,0,sum 1641 // We use the current number of symbols in the symbol table in lieu of 1642 // using nlist_idx in case we ever start trimming entries out 1643 N_INCL_indexes.push_back(sym_idx); 1644 type = eSymbolTypeScopeBegin; 1645 break; 1646 1647 case StabEndIncludeFile: 1648 // N_EINCL - include file end: name,,NO_SECT,0,0 1649 // Set the size of the N_BINCL to the terminating index of this N_EINCL 1650 // so that we can always skip the entire symbol if we need to navigate 1651 // more quickly at the source level when parsing STABS 1652 if ( !N_INCL_indexes.empty() ) 1653 { 1654 symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back()); 1655 symbol_ptr->SetByteSize(sym_idx + 1); 1656 symbol_ptr->SetSizeIsSibling(true); 1657 N_INCL_indexes.pop_back(); 1658 } 1659 type = eSymbolTypeScopeEnd; 1660 break; 1661 1662 case StabIncludeFileName: 1663 // N_SOL - #included file name: name,,n_sect,0,address 1664 type = eSymbolTypeHeaderFile; 1665 1666 // We currently don't use the header files on darwin 1667 if (minimize) 1668 add_nlist = false; 1669 break; 1670 1671 case StabCompilerParameters: 1672 // N_PARAMS - compiler parameters: name,,NO_SECT,0,0 1673 type = eSymbolTypeCompiler; 1674 break; 1675 1676 case StabCompilerVersion: 1677 // N_VERSION - compiler version: name,,NO_SECT,0,0 1678 type = eSymbolTypeCompiler; 1679 break; 1680 1681 case StabCompilerOptLevel: 1682 // N_OLEVEL - compiler -O level: name,,NO_SECT,0,0 1683 type = eSymbolTypeCompiler; 1684 break; 1685 1686 case StabParameter: 1687 // N_PSYM - parameter: name,,NO_SECT,type,offset 1688 type = eSymbolTypeVariable; 1689 break; 1690 1691 case StabAlternateEntry: 1692 // N_ENTRY - alternate entry: name,,n_sect,linenumber,address 1693 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1694 type = eSymbolTypeLineEntry; 1695 break; 1696 1697 //---------------------------------------------------------------------- 1698 // Left and Right Braces 1699 //---------------------------------------------------------------------- 1700 case StabLeftBracket: 1701 // N_LBRAC - left bracket: 0,,NO_SECT,nesting level,address 1702 // We use the current number of symbols in the symbol table in lieu of 1703 // using nlist_idx in case we ever start trimming entries out 1704 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1705 N_BRAC_indexes.push_back(sym_idx); 1706 type = eSymbolTypeScopeBegin; 1707 break; 1708 1709 case StabRightBracket: 1710 // N_RBRAC - right bracket: 0,,NO_SECT,nesting level,address 1711 // Set the size of the N_LBRAC to the terminating index of this N_RBRAC 1712 // so that we can always skip the entire symbol if we need to navigate 1713 // more quickly at the source level when parsing STABS 1714 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1715 if ( !N_BRAC_indexes.empty() ) 1716 { 1717 symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back()); 1718 symbol_ptr->SetByteSize(sym_idx + 1); 1719 symbol_ptr->SetSizeIsSibling(true); 1720 N_BRAC_indexes.pop_back(); 1721 } 1722 type = eSymbolTypeScopeEnd; 1723 break; 1724 1725 case StabDeletedIncludeFile: 1726 // N_EXCL - deleted include file: name,,NO_SECT,0,sum 1727 type = eSymbolTypeHeaderFile; 1728 break; 1729 1730 //---------------------------------------------------------------------- 1731 // COMM scopes 1732 //---------------------------------------------------------------------- 1733 case StabBeginCommon: 1734 // N_BCOMM - begin common: name,,NO_SECT,0,0 1735 // We use the current number of symbols in the symbol table in lieu of 1736 // using nlist_idx in case we ever start trimming entries out 1737 type = eSymbolTypeScopeBegin; 1738 N_COMM_indexes.push_back(sym_idx); 1739 break; 1740 1741 case StabEndCommonLocal: 1742 // N_ECOML - end common (local name): 0,,n_sect,0,address 1743 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1744 // Fall through 1745 1746 case StabEndCommon: 1747 // N_ECOMM - end common: name,,n_sect,0,0 1748 // Set the size of the N_BCOMM to the terminating index of this N_ECOMM/N_ECOML 1749 // so that we can always skip the entire symbol if we need to navigate 1750 // more quickly at the source level when parsing STABS 1751 if ( !N_COMM_indexes.empty() ) 1752 { 1753 symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back()); 1754 symbol_ptr->SetByteSize(sym_idx + 1); 1755 symbol_ptr->SetSizeIsSibling(true); 1756 N_COMM_indexes.pop_back(); 1757 } 1758 type = eSymbolTypeScopeEnd; 1759 break; 1760 1761 case StabLength: 1762 // N_LENG - second stab entry with length information 1763 type = eSymbolTypeAdditional; 1764 break; 1765 1766 default: break; 1767 } 1768 } 1769 else 1770 { 1771 //uint8_t n_pext = NlistMaskPrivateExternal & nlist.n_type; 1772 uint8_t n_type = NlistMaskType & nlist.n_type; 1773 sym[sym_idx].SetExternal((NlistMaskExternal & nlist.n_type) != 0); 1774 1775 switch (n_type) 1776 { 1777 case NListTypeIndirect: // N_INDR - Fall through 1778 case NListTypePreboundUndefined:// N_PBUD - Fall through 1779 case NListTypeUndefined: // N_UNDF 1780 type = eSymbolTypeUndefined; 1781 break; 1782 1783 case NListTypeAbsolute: // N_ABS 1784 type = eSymbolTypeAbsolute; 1785 break; 1786 1787 case NListTypeSection: // N_SECT 1788 { 1789 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value); 1790 1791 if (symbol_section == NULL) 1792 { 1793 // TODO: warn about this? 1794 add_nlist = false; 1795 break; 1796 } 1797 1798 if (TEXT_eh_frame_sectID == nlist.n_sect) 1799 { 1800 type = eSymbolTypeException; 1801 } 1802 else 1803 { 1804 uint32_t section_type = symbol_section->Get() & SectionFlagMaskSectionType; 1805 1806 switch (section_type) 1807 { 1808 case SectionTypeRegular: break; // regular section 1809 //case SectionTypeZeroFill: type = eSymbolTypeData; break; // zero fill on demand section 1810 case SectionTypeCStringLiterals: type = eSymbolTypeData; break; // section with only literal C strings 1811 case SectionType4ByteLiterals: type = eSymbolTypeData; break; // section with only 4 byte literals 1812 case SectionType8ByteLiterals: type = eSymbolTypeData; break; // section with only 8 byte literals 1813 case SectionTypeLiteralPointers: type = eSymbolTypeTrampoline; break; // section with only pointers to literals 1814 case SectionTypeNonLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only non-lazy symbol pointers 1815 case SectionTypeLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only lazy symbol pointers 1816 case SectionTypeSymbolStubs: type = eSymbolTypeTrampoline; break; // section with only symbol stubs, byte size of stub in the reserved2 field 1817 case SectionTypeModuleInitFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for initialization 1818 case SectionTypeModuleTermFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for termination 1819 //case SectionTypeCoalesced: type = eSymbolType; break; // section contains symbols that are to be coalesced 1820 //case SectionTypeZeroFillLarge: type = eSymbolTypeData; break; // zero fill on demand section (that can be larger than 4 gigabytes) 1821 case SectionTypeInterposing: type = eSymbolTypeTrampoline; break; // section with only pairs of function pointers for interposing 1822 case SectionType16ByteLiterals: type = eSymbolTypeData; break; // section with only 16 byte literals 1823 case SectionTypeDTraceObjectFormat: type = eSymbolTypeInstrumentation; break; 1824 case SectionTypeLazyDylibSymbolPointers: type = eSymbolTypeTrampoline; break; 1825 default: break; 1826 } 1827 1828 if (type == eSymbolTypeInvalid) 1829 { 1830 const char *symbol_sect_name = symbol_section->GetName().AsCString(); 1831 if (symbol_section->IsDescendant (text_section_sp.get())) 1832 { 1833 if (symbol_section->IsClear(SectionAttrUserPureInstructions | 1834 SectionAttrUserSelfModifyingCode | 1835 SectionAttrSytemSomeInstructions)) 1836 type = eSymbolTypeData; 1837 else 1838 type = eSymbolTypeCode; 1839 } 1840 else 1841 if (symbol_section->IsDescendant(data_section_sp.get())) 1842 { 1843 if (symbol_sect_name && ::strstr (symbol_sect_name, "__objc") == symbol_sect_name) 1844 { 1845 type = eSymbolTypeRuntime; 1846 1847 if (symbol_name && 1848 symbol_name[0] == '_' && 1849 symbol_name[1] == 'O' && 1850 symbol_name[2] == 'B') 1851 { 1852 llvm::StringRef symbol_name_ref(symbol_name); 1853 static const llvm::StringRef g_objc_v2_prefix_class ("_OBJC_CLASS_$_"); 1854 static const llvm::StringRef g_objc_v2_prefix_metaclass ("_OBJC_METACLASS_$_"); 1855 static const llvm::StringRef g_objc_v2_prefix_ivar ("_OBJC_IVAR_$_"); 1856 if (symbol_name_ref.startswith(g_objc_v2_prefix_class)) 1857 { 1858 symbol_name_non_abi_mangled = symbol_name + 1; 1859 symbol_name = symbol_name + g_objc_v2_prefix_class.size(); 1860 type = eSymbolTypeObjCClass; 1861 } 1862 else if (symbol_name_ref.startswith(g_objc_v2_prefix_metaclass)) 1863 { 1864 symbol_name_non_abi_mangled = symbol_name + 1; 1865 symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size(); 1866 type = eSymbolTypeObjCMetaClass; 1867 } 1868 else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar)) 1869 { 1870 symbol_name_non_abi_mangled = symbol_name + 1; 1871 symbol_name = symbol_name + g_objc_v2_prefix_ivar.size(); 1872 type = eSymbolTypeObjCIVar; 1873 } 1874 } 1875 } 1876 else 1877 if (symbol_sect_name && ::strstr (symbol_sect_name, "__gcc_except_tab") == symbol_sect_name) 1878 { 1879 type = eSymbolTypeException; 1880 } 1881 else 1882 { 1883 type = eSymbolTypeData; 1884 } 1885 } 1886 else 1887 if (symbol_sect_name && ::strstr (symbol_sect_name, "__IMPORT") == symbol_sect_name) 1888 { 1889 type = eSymbolTypeTrampoline; 1890 } 1891 else 1892 if (symbol_section->IsDescendant(objc_section_sp.get())) 1893 { 1894 type = eSymbolTypeRuntime; 1895 if (symbol_name && symbol_name[0] == '.') 1896 { 1897 llvm::StringRef symbol_name_ref(symbol_name); 1898 static const llvm::StringRef g_objc_v1_prefix_class (".objc_class_name_"); 1899 if (symbol_name_ref.startswith(g_objc_v1_prefix_class)) 1900 { 1901 symbol_name_non_abi_mangled = symbol_name; 1902 symbol_name = symbol_name + g_objc_v1_prefix_class.size(); 1903 type = eSymbolTypeObjCClass; 1904 } 1905 } 1906 } 1907 } 1908 } 1909 } 1910 break; 1911 } 1912 } 1913 1914 if (add_nlist) 1915 { 1916 uint64_t symbol_value = nlist.n_value; 1917 bool symbol_name_is_mangled = false; 1918 1919 if (symbol_name_non_abi_mangled) 1920 { 1921 sym[sym_idx].GetMangled().SetMangledName (symbol_name_non_abi_mangled); 1922 sym[sym_idx].GetMangled().SetDemangledName (symbol_name); 1923 } 1924 else 1925 { 1926 if (symbol_name && symbol_name[0] == '_') 1927 { 1928 symbol_name_is_mangled = symbol_name[1] == '_'; 1929 symbol_name++; // Skip the leading underscore 1930 } 1931 1932 if (symbol_name) 1933 { 1934 sym[sym_idx].GetMangled().SetValue(symbol_name, symbol_name_is_mangled); 1935 } 1936 } 1937 1938 if (is_debug == false) 1939 { 1940 if (type == eSymbolTypeCode) 1941 { 1942 // See if we can find a N_FUN entry for any code symbols. 1943 // If we do find a match, and the name matches, then we 1944 // can merge the two into just the function symbol to avoid 1945 // duplicate entries in the symbol table 1946 ValueToSymbolIndexMap::const_iterator pos = N_FUN_addr_to_sym_idx.find (nlist.n_value); 1947 if (pos != N_FUN_addr_to_sym_idx.end()) 1948 { 1949 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) || 1950 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName())) 1951 { 1952 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second; 1953 // We just need the flags from the linker symbol, so put these flags 1954 // into the N_FUN flags to avoid duplicate symbols in the symbol table 1955 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc); 1956 sym[sym_idx].Clear(); 1957 continue; 1958 } 1959 } 1960 } 1961 else if (type == eSymbolTypeData) 1962 { 1963 // See if we can find a N_STSYM entry for any data symbols. 1964 // If we do find a match, and the name matches, then we 1965 // can merge the two into just the Static symbol to avoid 1966 // duplicate entries in the symbol table 1967 ValueToSymbolIndexMap::const_iterator pos = N_STSYM_addr_to_sym_idx.find (nlist.n_value); 1968 if (pos != N_STSYM_addr_to_sym_idx.end()) 1969 { 1970 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) || 1971 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName())) 1972 { 1973 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second; 1974 // We just need the flags from the linker symbol, so put these flags 1975 // into the N_STSYM flags to avoid duplicate symbols in the symbol table 1976 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc); 1977 sym[sym_idx].Clear(); 1978 continue; 1979 } 1980 } 1981 } 1982 } 1983 if (symbol_section) 1984 { 1985 const addr_t section_file_addr = symbol_section->GetFileAddress(); 1986 if (symbol_byte_size == 0 && function_starts_count > 0) 1987 { 1988 addr_t symbol_lookup_file_addr = nlist.n_value; 1989 // Do an exact address match for non-ARM addresses, else get the closest since 1990 // the symbol might be a thumb symbol which has an address with bit zero set 1991 FunctionStarts::Entry *func_start_entry = function_starts.FindEntry (symbol_lookup_file_addr, !is_arm); 1992 if (is_arm && func_start_entry) 1993 { 1994 // Verify that the function start address is the symbol address (ARM) 1995 // or the symbol address + 1 (thumb) 1996 if (func_start_entry->addr != symbol_lookup_file_addr && 1997 func_start_entry->addr != (symbol_lookup_file_addr + 1)) 1998 { 1999 // Not the right entry, NULL it out... 2000 func_start_entry = NULL; 2001 } 2002 } 2003 if (func_start_entry) 2004 { 2005 func_start_entry->data = true; 2006 2007 addr_t symbol_file_addr = func_start_entry->addr; 2008 uint32_t symbol_flags = 0; 2009 if (is_arm) 2010 { 2011 if (symbol_file_addr & 1) 2012 symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB; 2013 symbol_file_addr &= 0xfffffffffffffffeull; 2014 } 2015 2016 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry); 2017 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize(); 2018 if (next_func_start_entry) 2019 { 2020 addr_t next_symbol_file_addr = next_func_start_entry->addr; 2021 // Be sure the clear the Thumb address bit when we calculate the size 2022 // from the current and next address 2023 if (is_arm) 2024 next_symbol_file_addr &= 0xfffffffffffffffeull; 2025 symbol_byte_size = std::min<lldb::addr_t>(next_symbol_file_addr - symbol_file_addr, section_end_file_addr - symbol_file_addr); 2026 } 2027 else 2028 { 2029 symbol_byte_size = section_end_file_addr - symbol_file_addr; 2030 } 2031 } 2032 } 2033 symbol_value -= section_file_addr; 2034 } 2035 2036 sym[sym_idx].SetID (nlist_idx); 2037 sym[sym_idx].SetType (type); 2038 sym[sym_idx].GetAddress().SetSection (symbol_section); 2039 sym[sym_idx].GetAddress().SetOffset (symbol_value); 2040 sym[sym_idx].SetFlags (nlist.n_type << 16 | nlist.n_desc); 2041 2042 if (symbol_byte_size > 0) 2043 sym[sym_idx].SetByteSize(symbol_byte_size); 2044 2045 ++sym_idx; 2046 } 2047 else 2048 { 2049 sym[sym_idx].Clear(); 2050 } 2051 2052 } 2053 2054 // STAB N_GSYM entries end up having a symbol type eSymbolTypeGlobal and when the symbol value 2055 // is zero, the address of the global ends up being in a non-STAB entry. Try and fix up all 2056 // such entries by figuring out what the address for the global is by looking up this non-STAB 2057 // entry and copying the value into the debug symbol's value to save us the hassle in the 2058 // debug symbol parser. 2059 2060 Symbol *global_symbol = NULL; 2061 for (nlist_idx = 0; 2062 nlist_idx < symtab_load_command.nsyms && (global_symbol = symtab->FindSymbolWithType (eSymbolTypeData, Symtab::eDebugYes, Symtab::eVisibilityAny, nlist_idx)) != NULL; 2063 nlist_idx++) 2064 { 2065 if (global_symbol->GetAddress().GetFileAddress() == 0) 2066 { 2067 std::vector<uint32_t> indexes; 2068 if (symtab->AppendSymbolIndexesWithName (global_symbol->GetMangled().GetName(), indexes) > 0) 2069 { 2070 std::vector<uint32_t>::const_iterator pos; 2071 std::vector<uint32_t>::const_iterator end = indexes.end(); 2072 for (pos = indexes.begin(); pos != end; ++pos) 2073 { 2074 symbol_ptr = symtab->SymbolAtIndex(*pos); 2075 if (symbol_ptr != global_symbol && symbol_ptr->IsDebug() == false) 2076 { 2077 global_symbol->GetAddress() = symbol_ptr->GetAddress(); 2078 break; 2079 } 2080 } 2081 } 2082 } 2083 } 2084 2085 uint32_t synthetic_sym_id = symtab_load_command.nsyms; 2086 2087 2088 if (function_starts_count > 0) 2089 { 2090 char synthetic_function_symbol[PATH_MAX]; 2091 uint32_t num_synthetic_function_symbols = 0; 2092 for (i=0; i<function_starts_count; ++i) 2093 { 2094 if (function_starts.GetEntryRef (i).data == false) 2095 ++num_synthetic_function_symbols; 2096 } 2097 2098 if (num_synthetic_function_symbols > 0) 2099 { 2100 if (num_syms < sym_idx + num_synthetic_function_symbols) 2101 { 2102 num_syms = sym_idx + num_synthetic_function_symbols; 2103 sym = symtab->Resize (num_syms); 2104 } 2105 uint32_t synthetic_function_symbol_idx = 0; 2106 for (i=0; i<function_starts_count; ++i) 2107 { 2108 const FunctionStarts::Entry *func_start_entry = function_starts.GetEntryAtIndex (i); 2109 if (func_start_entry->data == false) 2110 { 2111 addr_t symbol_file_addr = func_start_entry->addr; 2112 uint32_t symbol_flags = 0; 2113 if (is_arm) 2114 { 2115 if (symbol_file_addr & 1) 2116 symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB; 2117 symbol_file_addr &= 0xfffffffffffffffeull; 2118 } 2119 Address symbol_addr; 2120 if (module_sp->ResolveFileAddress (symbol_file_addr, symbol_addr)) 2121 { 2122 SectionSP symbol_section (symbol_addr.GetSection()); 2123 uint32_t symbol_byte_size = 0; 2124 if (symbol_section) 2125 { 2126 const addr_t section_file_addr = symbol_section->GetFileAddress(); 2127 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry); 2128 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize(); 2129 if (next_func_start_entry) 2130 { 2131 addr_t next_symbol_file_addr = next_func_start_entry->addr; 2132 if (is_arm) 2133 next_symbol_file_addr &= 0xfffffffffffffffeull; 2134 symbol_byte_size = std::min<lldb::addr_t>(next_symbol_file_addr - symbol_file_addr, section_end_file_addr - symbol_file_addr); 2135 } 2136 else 2137 { 2138 symbol_byte_size = section_end_file_addr - symbol_file_addr; 2139 } 2140 snprintf (synthetic_function_symbol, 2141 sizeof(synthetic_function_symbol), 2142 "___lldb_unnamed_function%u$$%s", 2143 ++synthetic_function_symbol_idx, 2144 module_sp->GetFileSpec().GetFilename().GetCString()); 2145 sym[sym_idx].SetID (synthetic_sym_id++); 2146 sym[sym_idx].GetMangled().SetDemangledName(synthetic_function_symbol); 2147 sym[sym_idx].SetType (eSymbolTypeCode); 2148 sym[sym_idx].SetIsSynthetic (true); 2149 sym[sym_idx].GetAddress() = symbol_addr; 2150 if (symbol_flags) 2151 sym[sym_idx].SetFlags (symbol_flags); 2152 if (symbol_byte_size) 2153 sym[sym_idx].SetByteSize (symbol_byte_size); 2154 ++sym_idx; 2155 } 2156 } 2157 } 2158 } 2159 } 2160 } 2161 2162 // Trim our symbols down to just what we ended up with after 2163 // removing any symbols. 2164 if (sym_idx < num_syms) 2165 { 2166 num_syms = sym_idx; 2167 sym = symtab->Resize (num_syms); 2168 } 2169 2170 // Now synthesize indirect symbols 2171 if (m_dysymtab.nindirectsyms != 0) 2172 { 2173 DataExtractor indirect_symbol_index_data (m_data, m_dysymtab.indirectsymoff, m_dysymtab.nindirectsyms * 4); 2174 2175 if (indirect_symbol_index_data.GetByteSize()) 2176 { 2177 NListIndexToSymbolIndexMap::const_iterator end_index_pos = m_nlist_idx_to_sym_idx.end(); 2178 2179 for (uint32_t sect_idx = 1; sect_idx < m_mach_sections.size(); ++sect_idx) 2180 { 2181 if ((m_mach_sections[sect_idx].flags & SectionFlagMaskSectionType) == SectionTypeSymbolStubs) 2182 { 2183 uint32_t symbol_stub_byte_size = m_mach_sections[sect_idx].reserved2; 2184 if (symbol_stub_byte_size == 0) 2185 continue; 2186 2187 const uint32_t num_symbol_stubs = m_mach_sections[sect_idx].size / symbol_stub_byte_size; 2188 2189 if (num_symbol_stubs == 0) 2190 continue; 2191 2192 const uint32_t symbol_stub_index_offset = m_mach_sections[sect_idx].reserved1; 2193 for (uint32_t stub_idx = 0; stub_idx < num_symbol_stubs; ++stub_idx) 2194 { 2195 const uint32_t symbol_stub_index = symbol_stub_index_offset + stub_idx; 2196 const lldb::addr_t symbol_stub_addr = m_mach_sections[sect_idx].addr + (stub_idx * symbol_stub_byte_size); 2197 uint32_t symbol_stub_offset = symbol_stub_index * 4; 2198 if (indirect_symbol_index_data.ValidOffsetForDataOfSize(symbol_stub_offset, 4)) 2199 { 2200 const uint32_t stub_sym_id = indirect_symbol_index_data.GetU32 (&symbol_stub_offset); 2201 if (stub_sym_id & (IndirectSymbolAbsolute | IndirectSymbolLocal)) 2202 continue; 2203 2204 NListIndexToSymbolIndexMap::const_iterator index_pos = m_nlist_idx_to_sym_idx.find (stub_sym_id); 2205 Symbol *stub_symbol = NULL; 2206 if (index_pos != end_index_pos) 2207 { 2208 // We have a remapping from the original nlist index to 2209 // a current symbol index, so just look this up by index 2210 stub_symbol = symtab->SymbolAtIndex (index_pos->second); 2211 } 2212 else 2213 { 2214 // We need to lookup a symbol using the original nlist 2215 // symbol index since this index is coming from the 2216 // S_SYMBOL_STUBS 2217 stub_symbol = symtab->FindSymbolByID (stub_sym_id); 2218 } 2219 2220 assert (stub_symbol); 2221 if (stub_symbol) 2222 { 2223 Address so_addr(symbol_stub_addr, section_list); 2224 2225 if (stub_symbol->GetType() == eSymbolTypeUndefined) 2226 { 2227 // Change the external symbol into a trampoline that makes sense 2228 // These symbols were N_UNDF N_EXT, and are useless to us, so we 2229 // can re-use them so we don't have to make up a synthetic symbol 2230 // for no good reason. 2231 stub_symbol->SetType (eSymbolTypeTrampoline); 2232 stub_symbol->SetExternal (false); 2233 stub_symbol->GetAddress() = so_addr; 2234 stub_symbol->SetByteSize (symbol_stub_byte_size); 2235 } 2236 else 2237 { 2238 // Make a synthetic symbol to describe the trampoline stub 2239 if (sym_idx >= num_syms) 2240 sym = symtab->Resize (++num_syms); 2241 sym[sym_idx].SetID (synthetic_sym_id++); 2242 sym[sym_idx].GetMangled() = stub_symbol->GetMangled(); 2243 sym[sym_idx].SetType (eSymbolTypeTrampoline); 2244 sym[sym_idx].SetIsSynthetic (true); 2245 sym[sym_idx].GetAddress() = so_addr; 2246 sym[sym_idx].SetByteSize (symbol_stub_byte_size); 2247 ++sym_idx; 2248 } 2249 } 2250 } 2251 } 2252 } 2253 } 2254 } 2255 } 2256 return symtab->GetNumSymbols(); 2257 } 2258 return 0; 2259 } 2260 2261 2262 void 2263 ObjectFileMachO::Dump (Stream *s) 2264 { 2265 ModuleSP module_sp(GetModule()); 2266 if (module_sp) 2267 { 2268 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2269 s->Printf("%p: ", this); 2270 s->Indent(); 2271 if (m_header.magic == HeaderMagic64 || m_header.magic == HeaderMagic64Swapped) 2272 s->PutCString("ObjectFileMachO64"); 2273 else 2274 s->PutCString("ObjectFileMachO32"); 2275 2276 ArchSpec header_arch(eArchTypeMachO, m_header.cputype, m_header.cpusubtype); 2277 2278 *s << ", file = '" << m_file << "', arch = " << header_arch.GetArchitectureName() << "\n"; 2279 2280 if (m_sections_ap.get()) 2281 m_sections_ap->Dump(s, NULL, true, UINT32_MAX); 2282 2283 if (m_symtab_ap.get()) 2284 m_symtab_ap->Dump(s, NULL, eSortOrderNone); 2285 } 2286 } 2287 2288 2289 bool 2290 ObjectFileMachO::GetUUID (lldb_private::UUID* uuid) 2291 { 2292 ModuleSP module_sp(GetModule()); 2293 if (module_sp) 2294 { 2295 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2296 struct uuid_command load_cmd; 2297 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic); 2298 uint32_t i; 2299 for (i=0; i<m_header.ncmds; ++i) 2300 { 2301 const uint32_t cmd_offset = offset; 2302 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL) 2303 break; 2304 2305 if (load_cmd.cmd == LoadCommandUUID) 2306 { 2307 const uint8_t *uuid_bytes = m_data.PeekData(offset, 16); 2308 if (uuid_bytes) 2309 { 2310 uuid->SetBytes (uuid_bytes); 2311 return true; 2312 } 2313 return false; 2314 } 2315 offset = cmd_offset + load_cmd.cmdsize; 2316 } 2317 } 2318 return false; 2319 } 2320 2321 2322 uint32_t 2323 ObjectFileMachO::GetDependentModules (FileSpecList& files) 2324 { 2325 uint32_t count = 0; 2326 ModuleSP module_sp(GetModule()); 2327 if (module_sp) 2328 { 2329 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2330 struct load_command load_cmd; 2331 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic); 2332 const bool resolve_path = false; // Don't resolve the dependend file paths since they may not reside on this system 2333 uint32_t i; 2334 for (i=0; i<m_header.ncmds; ++i) 2335 { 2336 const uint32_t cmd_offset = offset; 2337 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL) 2338 break; 2339 2340 switch (load_cmd.cmd) 2341 { 2342 case LoadCommandDylibLoad: 2343 case LoadCommandDylibLoadWeak: 2344 case LoadCommandDylibReexport: 2345 case LoadCommandDynamicLinkerLoad: 2346 case LoadCommandFixedVMShlibLoad: 2347 case LoadCommandDylibLoadUpward: 2348 { 2349 uint32_t name_offset = cmd_offset + m_data.GetU32(&offset); 2350 const char *path = m_data.PeekCStr(name_offset); 2351 // Skip any path that starts with '@' since these are usually: 2352 // @executable_path/.../file 2353 // @rpath/.../file 2354 if (path && path[0] != '@') 2355 { 2356 FileSpec file_spec(path, resolve_path); 2357 if (files.AppendIfUnique(file_spec)) 2358 count++; 2359 } 2360 } 2361 break; 2362 2363 default: 2364 break; 2365 } 2366 offset = cmd_offset + load_cmd.cmdsize; 2367 } 2368 } 2369 return count; 2370 } 2371 2372 lldb_private::Address 2373 ObjectFileMachO::GetEntryPointAddress () 2374 { 2375 // If the object file is not an executable it can't hold the entry point. m_entry_point_address 2376 // is initialized to an invalid address, so we can just return that. 2377 // If m_entry_point_address is valid it means we've found it already, so return the cached value. 2378 2379 if (!IsExecutable() || m_entry_point_address.IsValid()) 2380 return m_entry_point_address; 2381 2382 // Otherwise, look for the UnixThread or Thread command. The data for the Thread command is given in 2383 // /usr/include/mach-o.h, but it is basically: 2384 // 2385 // uint32_t flavor - this is the flavor argument you would pass to thread_get_state 2386 // uint32_t count - this is the count of longs in the thread state data 2387 // struct XXX_thread_state state - this is the structure from <machine/thread_status.h> corresponding to the flavor. 2388 // <repeat this trio> 2389 // 2390 // So we just keep reading the various register flavors till we find the GPR one, then read the PC out of there. 2391 // FIXME: We will need to have a "RegisterContext data provider" class at some point that can get all the registers 2392 // out of data in this form & attach them to a given thread. That should underlie the MacOS X User process plugin, 2393 // and we'll also need it for the MacOS X Core File process plugin. When we have that we can also use it here. 2394 // 2395 // For now we hard-code the offsets and flavors we need: 2396 // 2397 // 2398 2399 ModuleSP module_sp(GetModule()); 2400 if (module_sp) 2401 { 2402 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2403 struct load_command load_cmd; 2404 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic); 2405 uint32_t i; 2406 lldb::addr_t start_address = LLDB_INVALID_ADDRESS; 2407 bool done = false; 2408 2409 for (i=0; i<m_header.ncmds; ++i) 2410 { 2411 const uint32_t cmd_offset = offset; 2412 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL) 2413 break; 2414 2415 switch (load_cmd.cmd) 2416 { 2417 case LoadCommandUnixThread: 2418 case LoadCommandThread: 2419 { 2420 while (offset < cmd_offset + load_cmd.cmdsize) 2421 { 2422 uint32_t flavor = m_data.GetU32(&offset); 2423 uint32_t count = m_data.GetU32(&offset); 2424 if (count == 0) 2425 { 2426 // We've gotten off somehow, log and exit; 2427 return m_entry_point_address; 2428 } 2429 2430 switch (m_header.cputype) 2431 { 2432 case llvm::MachO::CPUTypeARM: 2433 if (flavor == 1) // ARM_THREAD_STATE from mach/arm/thread_status.h 2434 { 2435 offset += 60; // This is the offset of pc in the GPR thread state data structure. 2436 start_address = m_data.GetU32(&offset); 2437 done = true; 2438 } 2439 break; 2440 case llvm::MachO::CPUTypeI386: 2441 if (flavor == 1) // x86_THREAD_STATE32 from mach/i386/thread_status.h 2442 { 2443 offset += 40; // This is the offset of eip in the GPR thread state data structure. 2444 start_address = m_data.GetU32(&offset); 2445 done = true; 2446 } 2447 break; 2448 case llvm::MachO::CPUTypeX86_64: 2449 if (flavor == 4) // x86_THREAD_STATE64 from mach/i386/thread_status.h 2450 { 2451 offset += 16 * 8; // This is the offset of rip in the GPR thread state data structure. 2452 start_address = m_data.GetU64(&offset); 2453 done = true; 2454 } 2455 break; 2456 default: 2457 return m_entry_point_address; 2458 } 2459 // Haven't found the GPR flavor yet, skip over the data for this flavor: 2460 if (done) 2461 break; 2462 offset += count * 4; 2463 } 2464 } 2465 break; 2466 case LoadCommandMain: 2467 { 2468 ConstString text_segment_name ("__TEXT"); 2469 uint64_t entryoffset = m_data.GetU64(&offset); 2470 SectionSP text_segment_sp = GetSectionList()->FindSectionByName(text_segment_name); 2471 if (text_segment_sp) 2472 { 2473 done = true; 2474 start_address = text_segment_sp->GetFileAddress() + entryoffset; 2475 } 2476 } 2477 2478 default: 2479 break; 2480 } 2481 if (done) 2482 break; 2483 2484 // Go to the next load command: 2485 offset = cmd_offset + load_cmd.cmdsize; 2486 } 2487 2488 if (start_address != LLDB_INVALID_ADDRESS) 2489 { 2490 // We got the start address from the load commands, so now resolve that address in the sections 2491 // of this ObjectFile: 2492 if (!m_entry_point_address.ResolveAddressUsingFileSections (start_address, GetSectionList())) 2493 { 2494 m_entry_point_address.Clear(); 2495 } 2496 } 2497 else 2498 { 2499 // We couldn't read the UnixThread load command - maybe it wasn't there. As a fallback look for the 2500 // "start" symbol in the main executable. 2501 2502 ModuleSP module_sp (GetModule()); 2503 2504 if (module_sp) 2505 { 2506 SymbolContextList contexts; 2507 SymbolContext context; 2508 if (module_sp->FindSymbolsWithNameAndType(ConstString ("start"), eSymbolTypeCode, contexts)) 2509 { 2510 if (contexts.GetContextAtIndex(0, context)) 2511 m_entry_point_address = context.symbol->GetAddress(); 2512 } 2513 } 2514 } 2515 } 2516 2517 return m_entry_point_address; 2518 2519 } 2520 2521 lldb_private::Address 2522 ObjectFileMachO::GetHeaderAddress () 2523 { 2524 lldb_private::Address header_addr; 2525 SectionList *section_list = GetSectionList(); 2526 if (section_list) 2527 { 2528 SectionSP text_segment_sp (section_list->FindSectionByName (GetSegmentNameTEXT())); 2529 if (text_segment_sp) 2530 { 2531 header_addr.SetSection (text_segment_sp); 2532 header_addr.SetOffset (0); 2533 } 2534 } 2535 return header_addr; 2536 } 2537 2538 uint32_t 2539 ObjectFileMachO::GetNumThreadContexts () 2540 { 2541 ModuleSP module_sp(GetModule()); 2542 if (module_sp) 2543 { 2544 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2545 if (!m_thread_context_offsets_valid) 2546 { 2547 m_thread_context_offsets_valid = true; 2548 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic); 2549 FileRangeArray::Entry file_range; 2550 thread_command thread_cmd; 2551 for (uint32_t i=0; i<m_header.ncmds; ++i) 2552 { 2553 const uint32_t cmd_offset = offset; 2554 if (m_data.GetU32(&offset, &thread_cmd, 2) == NULL) 2555 break; 2556 2557 if (thread_cmd.cmd == LoadCommandThread) 2558 { 2559 file_range.SetRangeBase (offset); 2560 file_range.SetByteSize (thread_cmd.cmdsize - 8); 2561 m_thread_context_offsets.Append (file_range); 2562 } 2563 offset = cmd_offset + thread_cmd.cmdsize; 2564 } 2565 } 2566 } 2567 return m_thread_context_offsets.GetSize(); 2568 } 2569 2570 lldb::RegisterContextSP 2571 ObjectFileMachO::GetThreadContextAtIndex (uint32_t idx, lldb_private::Thread &thread) 2572 { 2573 lldb::RegisterContextSP reg_ctx_sp; 2574 2575 ModuleSP module_sp(GetModule()); 2576 if (module_sp) 2577 { 2578 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2579 if (!m_thread_context_offsets_valid) 2580 GetNumThreadContexts (); 2581 2582 const FileRangeArray::Entry *thread_context_file_range = m_thread_context_offsets.GetEntryAtIndex (idx); 2583 2584 DataExtractor data (m_data, 2585 thread_context_file_range->GetRangeBase(), 2586 thread_context_file_range->GetByteSize()); 2587 2588 switch (m_header.cputype) 2589 { 2590 case llvm::MachO::CPUTypeARM: 2591 reg_ctx_sp.reset (new RegisterContextDarwin_arm_Mach (thread, data)); 2592 break; 2593 2594 case llvm::MachO::CPUTypeI386: 2595 reg_ctx_sp.reset (new RegisterContextDarwin_i386_Mach (thread, data)); 2596 break; 2597 2598 case llvm::MachO::CPUTypeX86_64: 2599 reg_ctx_sp.reset (new RegisterContextDarwin_x86_64_Mach (thread, data)); 2600 break; 2601 } 2602 } 2603 return reg_ctx_sp; 2604 } 2605 2606 2607 ObjectFile::Type 2608 ObjectFileMachO::CalculateType() 2609 { 2610 switch (m_header.filetype) 2611 { 2612 case HeaderFileTypeObject: // 0x1u MH_OBJECT 2613 if (GetAddressByteSize () == 4) 2614 { 2615 // 32 bit kexts are just object files, but they do have a valid 2616 // UUID load command. 2617 UUID uuid; 2618 if (GetUUID(&uuid)) 2619 { 2620 // this checking for the UUID load command is not enough 2621 // we could eventually look for the symbol named 2622 // "OSKextGetCurrentIdentifier" as this is required of kexts 2623 if (m_strata == eStrataInvalid) 2624 m_strata = eStrataKernel; 2625 return eTypeSharedLibrary; 2626 } 2627 } 2628 return eTypeObjectFile; 2629 2630 case HeaderFileTypeExecutable: return eTypeExecutable; // 0x2u MH_EXECUTE 2631 case HeaderFileTypeFixedVMShlib: return eTypeSharedLibrary; // 0x3u MH_FVMLIB 2632 case HeaderFileTypeCore: return eTypeCoreFile; // 0x4u MH_CORE 2633 case HeaderFileTypePreloadedExecutable: return eTypeSharedLibrary; // 0x5u MH_PRELOAD 2634 case HeaderFileTypeDynamicShlib: return eTypeSharedLibrary; // 0x6u MH_DYLIB 2635 case HeaderFileTypeDynamicLinkEditor: return eTypeDynamicLinker; // 0x7u MH_DYLINKER 2636 case HeaderFileTypeBundle: return eTypeSharedLibrary; // 0x8u MH_BUNDLE 2637 case HeaderFileTypeDynamicShlibStub: return eTypeStubLibrary; // 0x9u MH_DYLIB_STUB 2638 case HeaderFileTypeDSYM: return eTypeDebugInfo; // 0xAu MH_DSYM 2639 case HeaderFileTypeKextBundle: return eTypeSharedLibrary; // 0xBu MH_KEXT_BUNDLE 2640 default: 2641 break; 2642 } 2643 return eTypeUnknown; 2644 } 2645 2646 ObjectFile::Strata 2647 ObjectFileMachO::CalculateStrata() 2648 { 2649 switch (m_header.filetype) 2650 { 2651 case HeaderFileTypeObject: // 0x1u MH_OBJECT 2652 { 2653 // 32 bit kexts are just object files, but they do have a valid 2654 // UUID load command. 2655 UUID uuid; 2656 if (GetUUID(&uuid)) 2657 { 2658 // this checking for the UUID load command is not enough 2659 // we could eventually look for the symbol named 2660 // "OSKextGetCurrentIdentifier" as this is required of kexts 2661 if (m_type == eTypeInvalid) 2662 m_type = eTypeSharedLibrary; 2663 2664 return eStrataKernel; 2665 } 2666 } 2667 return eStrataUnknown; 2668 2669 case HeaderFileTypeExecutable: // 0x2u MH_EXECUTE 2670 // Check for the MH_DYLDLINK bit in the flags 2671 if (m_header.flags & HeaderFlagBitIsDynamicLinkObject) 2672 { 2673 return eStrataUser; 2674 } 2675 else 2676 { 2677 SectionList *section_list = GetSectionList(); 2678 if (section_list) 2679 { 2680 static ConstString g_kld_section_name ("__KLD"); 2681 if (section_list->FindSectionByName(g_kld_section_name)) 2682 return eStrataKernel; 2683 } 2684 } 2685 return eStrataRawImage; 2686 2687 case HeaderFileTypeFixedVMShlib: return eStrataUser; // 0x3u MH_FVMLIB 2688 case HeaderFileTypeCore: return eStrataUnknown; // 0x4u MH_CORE 2689 case HeaderFileTypePreloadedExecutable: return eStrataRawImage; // 0x5u MH_PRELOAD 2690 case HeaderFileTypeDynamicShlib: return eStrataUser; // 0x6u MH_DYLIB 2691 case HeaderFileTypeDynamicLinkEditor: return eStrataUser; // 0x7u MH_DYLINKER 2692 case HeaderFileTypeBundle: return eStrataUser; // 0x8u MH_BUNDLE 2693 case HeaderFileTypeDynamicShlibStub: return eStrataUser; // 0x9u MH_DYLIB_STUB 2694 case HeaderFileTypeDSYM: return eStrataUnknown; // 0xAu MH_DSYM 2695 case HeaderFileTypeKextBundle: return eStrataKernel; // 0xBu MH_KEXT_BUNDLE 2696 default: 2697 break; 2698 } 2699 return eStrataUnknown; 2700 } 2701 2702 2703 uint32_t 2704 ObjectFileMachO::GetVersion (uint32_t *versions, uint32_t num_versions) 2705 { 2706 ModuleSP module_sp(GetModule()); 2707 if (module_sp) 2708 { 2709 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2710 struct dylib_command load_cmd; 2711 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic); 2712 uint32_t version_cmd = 0; 2713 uint64_t version = 0; 2714 uint32_t i; 2715 for (i=0; i<m_header.ncmds; ++i) 2716 { 2717 const uint32_t cmd_offset = offset; 2718 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL) 2719 break; 2720 2721 if (load_cmd.cmd == LoadCommandDylibIdent) 2722 { 2723 if (version_cmd == 0) 2724 { 2725 version_cmd = load_cmd.cmd; 2726 if (m_data.GetU32(&offset, &load_cmd.dylib, 4) == NULL) 2727 break; 2728 version = load_cmd.dylib.current_version; 2729 } 2730 break; // Break for now unless there is another more complete version 2731 // number load command in the future. 2732 } 2733 offset = cmd_offset + load_cmd.cmdsize; 2734 } 2735 2736 if (version_cmd == LoadCommandDylibIdent) 2737 { 2738 if (versions != NULL && num_versions > 0) 2739 { 2740 if (num_versions > 0) 2741 versions[0] = (version & 0xFFFF0000ull) >> 16; 2742 if (num_versions > 1) 2743 versions[1] = (version & 0x0000FF00ull) >> 8; 2744 if (num_versions > 2) 2745 versions[2] = (version & 0x000000FFull); 2746 // Fill in an remaining version numbers with invalid values 2747 for (i=3; i<num_versions; ++i) 2748 versions[i] = UINT32_MAX; 2749 } 2750 // The LC_ID_DYLIB load command has a version with 3 version numbers 2751 // in it, so always return 3 2752 return 3; 2753 } 2754 } 2755 return false; 2756 } 2757 2758 bool 2759 ObjectFileMachO::GetArchitecture (ArchSpec &arch) 2760 { 2761 ModuleSP module_sp(GetModule()); 2762 if (module_sp) 2763 { 2764 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2765 arch.SetArchitecture (eArchTypeMachO, m_header.cputype, m_header.cpusubtype); 2766 2767 // Files with type MH_PRELOAD are currently used in cases where the image 2768 // debugs at the addresses in the file itself. Below we set the OS to 2769 // unknown to make sure we use the DynamicLoaderStatic()... 2770 if (m_header.filetype == HeaderFileTypePreloadedExecutable) 2771 { 2772 arch.GetTriple().setOS (llvm::Triple::UnknownOS); 2773 } 2774 return true; 2775 } 2776 return false; 2777 } 2778 2779 2780 //------------------------------------------------------------------ 2781 // PluginInterface protocol 2782 //------------------------------------------------------------------ 2783 const char * 2784 ObjectFileMachO::GetPluginName() 2785 { 2786 return "ObjectFileMachO"; 2787 } 2788 2789 const char * 2790 ObjectFileMachO::GetShortPluginName() 2791 { 2792 return GetPluginNameStatic(); 2793 } 2794 2795 uint32_t 2796 ObjectFileMachO::GetPluginVersion() 2797 { 2798 return 1; 2799 } 2800 2801