1 //===-- DynamicLoaderDarwin.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 "DynamicLoaderDarwin.h" 11 12 #include "lldb/Breakpoint/StoppointCallbackContext.h" 13 #include "lldb/Core/Debugger.h" 14 #include "lldb/Core/Module.h" 15 #include "lldb/Core/ModuleSpec.h" 16 #include "lldb/Core/PluginManager.h" 17 #include "lldb/Core/Section.h" 18 #include "lldb/Core/State.h" 19 #include "lldb/Expression/DiagnosticManager.h" 20 #include "lldb/Host/FileSystem.h" 21 #include "lldb/Symbol/ClangASTContext.h" 22 #include "lldb/Symbol/Function.h" 23 #include "lldb/Symbol/ObjectFile.h" 24 #include "lldb/Target/ABI.h" 25 #include "lldb/Target/ObjCLanguageRuntime.h" 26 #include "lldb/Target/RegisterContext.h" 27 #include "lldb/Target/StackFrame.h" 28 #include "lldb/Target/Target.h" 29 #include "lldb/Target/Thread.h" 30 #include "lldb/Target/ThreadPlanCallFunction.h" 31 #include "lldb/Target/ThreadPlanRunToAddress.h" 32 #include "lldb/Utility/DataBuffer.h" 33 #include "lldb/Utility/DataBufferHeap.h" 34 #include "lldb/Utility/Log.h" 35 36 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN 37 #ifdef ENABLE_DEBUG_PRINTF 38 #include <stdio.h> 39 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__) 40 #else 41 #define DEBUG_PRINTF(fmt, ...) 42 #endif 43 44 #ifndef __APPLE__ 45 #include "Utility/UuidCompatibility.h" 46 #else 47 #include <uuid/uuid.h> 48 #endif 49 50 using namespace lldb; 51 using namespace lldb_private; 52 53 //---------------------------------------------------------------------- 54 // Constructor 55 //---------------------------------------------------------------------- 56 DynamicLoaderDarwin::DynamicLoaderDarwin(Process *process) 57 : DynamicLoader(process), m_dyld_module_wp(), m_libpthread_module_wp(), 58 m_pthread_getspecific_addr(), m_tid_to_tls_map(), m_dyld_image_infos(), 59 m_dyld_image_infos_stop_id(UINT32_MAX), m_dyld(), m_mutex() {} 60 61 //---------------------------------------------------------------------- 62 // Destructor 63 //---------------------------------------------------------------------- 64 DynamicLoaderDarwin::~DynamicLoaderDarwin() {} 65 66 //------------------------------------------------------------------ 67 /// Called after attaching a process. 68 /// 69 /// Allow DynamicLoader plug-ins to execute some code after 70 /// attaching to a process. 71 //------------------------------------------------------------------ 72 void DynamicLoaderDarwin::DidAttach() { 73 PrivateInitialize(m_process); 74 DoInitialImageFetch(); 75 SetNotificationBreakpoint(); 76 } 77 78 //------------------------------------------------------------------ 79 /// Called after attaching a process. 80 /// 81 /// Allow DynamicLoader plug-ins to execute some code after 82 /// attaching to a process. 83 //------------------------------------------------------------------ 84 void DynamicLoaderDarwin::DidLaunch() { 85 PrivateInitialize(m_process); 86 DoInitialImageFetch(); 87 SetNotificationBreakpoint(); 88 } 89 90 //---------------------------------------------------------------------- 91 // Clear out the state of this class. 92 //---------------------------------------------------------------------- 93 void DynamicLoaderDarwin::Clear(bool clear_process) { 94 std::lock_guard<std::recursive_mutex> guard(m_mutex); 95 if (clear_process) 96 m_process = NULL; 97 m_dyld_image_infos.clear(); 98 m_dyld_image_infos_stop_id = UINT32_MAX; 99 m_dyld.Clear(false); 100 } 101 102 ModuleSP DynamicLoaderDarwin::FindTargetModuleForImageInfo( 103 ImageInfo &image_info, bool can_create, bool *did_create_ptr) { 104 if (did_create_ptr) 105 *did_create_ptr = false; 106 107 Target &target = m_process->GetTarget(); 108 const ModuleList &target_images = target.GetImages(); 109 ModuleSpec module_spec(image_info.file_spec); 110 module_spec.GetUUID() = image_info.uuid; 111 ModuleSP module_sp(target_images.FindFirstModule(module_spec)); 112 113 if (module_sp && !module_spec.GetUUID().IsValid() && 114 !module_sp->GetUUID().IsValid()) { 115 // No UUID, we must rely upon the cached module modification time and the 116 // modification time of the file on disk 117 if (module_sp->GetModificationTime() != 118 FileSystem::GetModificationTime(module_sp->GetFileSpec())) 119 module_sp.reset(); 120 } 121 122 if (!module_sp) { 123 if (can_create) { 124 module_sp = target.GetSharedModule(module_spec); 125 if (!module_sp || module_sp->GetObjectFile() == NULL) 126 module_sp = m_process->ReadModuleFromMemory(image_info.file_spec, 127 image_info.address); 128 129 if (did_create_ptr) 130 *did_create_ptr = (bool)module_sp; 131 } 132 } 133 return module_sp; 134 } 135 136 void DynamicLoaderDarwin::UnloadImages( 137 const std::vector<lldb::addr_t> &solib_addresses) { 138 std::lock_guard<std::recursive_mutex> guard(m_mutex); 139 if (m_process->GetStopID() == m_dyld_image_infos_stop_id) 140 return; 141 142 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 143 Target &target = m_process->GetTarget(); 144 if (log) 145 log->Printf("Removing %" PRId64 " modules.", 146 (uint64_t)solib_addresses.size()); 147 148 ModuleList unloaded_module_list; 149 150 for (addr_t solib_addr : solib_addresses) { 151 Address header; 152 if (header.SetLoadAddress(solib_addr, &target)) { 153 if (header.GetOffset() == 0) { 154 ModuleSP module_to_remove(header.GetModule()); 155 if (module_to_remove.get()) { 156 if (log) 157 log->Printf("Removing module at address 0x%" PRIx64, solib_addr); 158 // remove the sections from the Target 159 UnloadSections(module_to_remove); 160 // add this to the list of modules to remove 161 unloaded_module_list.AppendIfNeeded(module_to_remove); 162 // remove the entry from the m_dyld_image_infos 163 ImageInfo::collection::iterator pos, end = m_dyld_image_infos.end(); 164 for (pos = m_dyld_image_infos.begin(); pos != end; pos++) { 165 if (solib_addr == (*pos).address) { 166 m_dyld_image_infos.erase(pos); 167 break; 168 } 169 } 170 } 171 } 172 } 173 } 174 175 if (unloaded_module_list.GetSize() > 0) { 176 if (log) { 177 log->PutCString("Unloaded:"); 178 unloaded_module_list.LogUUIDAndPaths( 179 log, "DynamicLoaderDarwin::UnloadModules"); 180 } 181 m_process->GetTarget().GetImages().Remove(unloaded_module_list); 182 m_dyld_image_infos_stop_id = m_process->GetStopID(); 183 } 184 } 185 186 void DynamicLoaderDarwin::UnloadAllImages() { 187 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 188 ModuleList unloaded_modules_list; 189 190 Target &target = m_process->GetTarget(); 191 const ModuleList &target_modules = target.GetImages(); 192 std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); 193 194 size_t num_modules = target_modules.GetSize(); 195 ModuleSP dyld_sp(GetDYLDModule()); 196 197 for (size_t i = 0; i < num_modules; i++) { 198 ModuleSP module_sp = target_modules.GetModuleAtIndexUnlocked(i); 199 200 // Don't remove dyld - else we'll lose our breakpoint notifying us about 201 // libraries being re-loaded... 202 if (module_sp.get() != nullptr && module_sp.get() != dyld_sp.get()) { 203 UnloadSections(module_sp); 204 unloaded_modules_list.Append(module_sp); 205 } 206 } 207 208 if (unloaded_modules_list.GetSize() != 0) { 209 if (log) { 210 log->PutCString("Unloaded:"); 211 unloaded_modules_list.LogUUIDAndPaths( 212 log, "DynamicLoaderDarwin::UnloadAllImages"); 213 } 214 target.GetImages().Remove(unloaded_modules_list); 215 m_dyld_image_infos.clear(); 216 m_dyld_image_infos_stop_id = m_process->GetStopID(); 217 } 218 } 219 220 //---------------------------------------------------------------------- 221 // Update the load addresses for all segments in MODULE using the updated INFO 222 // that is passed in. 223 //---------------------------------------------------------------------- 224 bool DynamicLoaderDarwin::UpdateImageLoadAddress(Module *module, 225 ImageInfo &info) { 226 bool changed = false; 227 if (module) { 228 ObjectFile *image_object_file = module->GetObjectFile(); 229 if (image_object_file) { 230 SectionList *section_list = image_object_file->GetSectionList(); 231 if (section_list) { 232 std::vector<uint32_t> inaccessible_segment_indexes; 233 // We now know the slide amount, so go through all sections and update 234 // the load addresses with the correct values. 235 const size_t num_segments = info.segments.size(); 236 for (size_t i = 0; i < num_segments; ++i) { 237 // Only load a segment if it has protections. Things like __PAGEZERO 238 // don't have any protections, and they shouldn't be slid 239 SectionSP section_sp( 240 section_list->FindSectionByName(info.segments[i].name)); 241 242 if (info.segments[i].maxprot == 0) { 243 inaccessible_segment_indexes.push_back(i); 244 } else { 245 const addr_t new_section_load_addr = 246 info.segments[i].vmaddr + info.slide; 247 static ConstString g_section_name_LINKEDIT("__LINKEDIT"); 248 249 if (section_sp) { 250 // __LINKEDIT sections from files in the shared cache can overlap 251 // so check to see what the segment name is and pass "false" so 252 // we don't warn of overlapping "Section" objects, and "true" for 253 // all other sections. 254 const bool warn_multiple = 255 section_sp->GetName() != g_section_name_LINKEDIT; 256 257 changed = m_process->GetTarget().SetSectionLoadAddress( 258 section_sp, new_section_load_addr, warn_multiple); 259 } else { 260 Host::SystemLog( 261 Host::eSystemLogWarning, 262 "warning: unable to find and load segment named '%s' at " 263 "0x%" PRIx64 " in '%s' in macosx dynamic loader plug-in.\n", 264 info.segments[i].name.AsCString("<invalid>"), 265 (uint64_t)new_section_load_addr, 266 image_object_file->GetFileSpec().GetPath().c_str()); 267 } 268 } 269 } 270 271 // If the loaded the file (it changed) and we have segments that are 272 // not readable or writeable, add them to the invalid memory region 273 // cache for the process. This will typically only be the __PAGEZERO 274 // segment in the main executable. We might be able to apply this more 275 // generally to more sections that have no protections in the future, 276 // but for now we are going to just do __PAGEZERO. 277 if (changed && !inaccessible_segment_indexes.empty()) { 278 for (uint32_t i = 0; i < inaccessible_segment_indexes.size(); ++i) { 279 const uint32_t seg_idx = inaccessible_segment_indexes[i]; 280 SectionSP section_sp( 281 section_list->FindSectionByName(info.segments[seg_idx].name)); 282 283 if (section_sp) { 284 static ConstString g_pagezero_section_name("__PAGEZERO"); 285 if (g_pagezero_section_name == section_sp->GetName()) { 286 // __PAGEZERO never slides... 287 const lldb::addr_t vmaddr = info.segments[seg_idx].vmaddr; 288 const lldb::addr_t vmsize = info.segments[seg_idx].vmsize; 289 Process::LoadRange pagezero_range(vmaddr, vmsize); 290 m_process->AddInvalidMemoryRegion(pagezero_range); 291 } 292 } 293 } 294 } 295 } 296 } 297 } 298 // We might have an in memory image that was loaded as soon as it was created 299 if (info.load_stop_id == m_process->GetStopID()) 300 changed = true; 301 else if (changed) { 302 // Update the stop ID when this library was updated 303 info.load_stop_id = m_process->GetStopID(); 304 } 305 return changed; 306 } 307 308 //---------------------------------------------------------------------- 309 // Unload the segments in MODULE using the INFO that is passed in. 310 //---------------------------------------------------------------------- 311 bool DynamicLoaderDarwin::UnloadModuleSections(Module *module, 312 ImageInfo &info) { 313 bool changed = false; 314 if (module) { 315 ObjectFile *image_object_file = module->GetObjectFile(); 316 if (image_object_file) { 317 SectionList *section_list = image_object_file->GetSectionList(); 318 if (section_list) { 319 const size_t num_segments = info.segments.size(); 320 for (size_t i = 0; i < num_segments; ++i) { 321 SectionSP section_sp( 322 section_list->FindSectionByName(info.segments[i].name)); 323 if (section_sp) { 324 const addr_t old_section_load_addr = 325 info.segments[i].vmaddr + info.slide; 326 if (m_process->GetTarget().SetSectionUnloaded( 327 section_sp, old_section_load_addr)) 328 changed = true; 329 } else { 330 Host::SystemLog(Host::eSystemLogWarning, 331 "warning: unable to find and unload segment named " 332 "'%s' in '%s' in macosx dynamic loader plug-in.\n", 333 info.segments[i].name.AsCString("<invalid>"), 334 image_object_file->GetFileSpec().GetPath().c_str()); 335 } 336 } 337 } 338 } 339 } 340 return changed; 341 } 342 343 // Given a JSON dictionary (from debugserver, most likely) of binary images 344 // loaded in the inferior process, add the images to the ImageInfo collection. 345 346 bool DynamicLoaderDarwin::JSONImageInformationIntoImageInfo( 347 StructuredData::ObjectSP image_details, 348 ImageInfo::collection &image_infos) { 349 StructuredData::ObjectSP images_sp = 350 image_details->GetAsDictionary()->GetValueForKey("images"); 351 if (images_sp.get() == nullptr) 352 return false; 353 354 image_infos.resize(images_sp->GetAsArray()->GetSize()); 355 356 for (size_t i = 0; i < image_infos.size(); i++) { 357 StructuredData::ObjectSP image_sp = 358 images_sp->GetAsArray()->GetItemAtIndex(i); 359 if (image_sp.get() == nullptr || image_sp->GetAsDictionary() == nullptr) 360 return false; 361 StructuredData::Dictionary *image = image_sp->GetAsDictionary(); 362 if (image->HasKey("load_address") == false || 363 image->HasKey("pathname") == false || 364 image->HasKey("mod_date") == false || 365 image->HasKey("mach_header") == false || 366 image->GetValueForKey("mach_header")->GetAsDictionary() == nullptr || 367 image->HasKey("segments") == false || 368 image->GetValueForKey("segments")->GetAsArray() == nullptr || 369 image->HasKey("uuid") == false) { 370 return false; 371 } 372 image_infos[i].address = 373 image->GetValueForKey("load_address")->GetAsInteger()->GetValue(); 374 image_infos[i].mod_date = 375 image->GetValueForKey("mod_date")->GetAsInteger()->GetValue(); 376 image_infos[i].file_spec.SetFile( 377 image->GetValueForKey("pathname")->GetAsString()->GetValue(), false); 378 379 StructuredData::Dictionary *mh = 380 image->GetValueForKey("mach_header")->GetAsDictionary(); 381 image_infos[i].header.magic = 382 mh->GetValueForKey("magic")->GetAsInteger()->GetValue(); 383 image_infos[i].header.cputype = 384 mh->GetValueForKey("cputype")->GetAsInteger()->GetValue(); 385 image_infos[i].header.cpusubtype = 386 mh->GetValueForKey("cpusubtype")->GetAsInteger()->GetValue(); 387 image_infos[i].header.filetype = 388 mh->GetValueForKey("filetype")->GetAsInteger()->GetValue(); 389 390 if (image->HasKey("min_version_os_name")) { 391 std::string os_name = image->GetValueForKey("min_version_os_name") 392 ->GetAsString() 393 ->GetValue(); 394 if (os_name == "macosx") 395 image_infos[i].os_type = llvm::Triple::MacOSX; 396 else if (os_name == "ios" || os_name == "iphoneos") 397 image_infos[i].os_type = llvm::Triple::IOS; 398 else if (os_name == "tvos") 399 image_infos[i].os_type = llvm::Triple::TvOS; 400 else if (os_name == "watchos") 401 image_infos[i].os_type = llvm::Triple::WatchOS; 402 } 403 if (image->HasKey("min_version_os_sdk")) { 404 image_infos[i].min_version_os_sdk = 405 image->GetValueForKey("min_version_os_sdk") 406 ->GetAsString() 407 ->GetValue(); 408 } 409 410 // Fields that aren't used by DynamicLoaderDarwin so debugserver doesn't 411 // currently send them in the reply. 412 413 if (mh->HasKey("flags")) 414 image_infos[i].header.flags = 415 mh->GetValueForKey("flags")->GetAsInteger()->GetValue(); 416 else 417 image_infos[i].header.flags = 0; 418 419 if (mh->HasKey("ncmds")) 420 image_infos[i].header.ncmds = 421 mh->GetValueForKey("ncmds")->GetAsInteger()->GetValue(); 422 else 423 image_infos[i].header.ncmds = 0; 424 425 if (mh->HasKey("sizeofcmds")) 426 image_infos[i].header.sizeofcmds = 427 mh->GetValueForKey("sizeofcmds")->GetAsInteger()->GetValue(); 428 else 429 image_infos[i].header.sizeofcmds = 0; 430 431 StructuredData::Array *segments = 432 image->GetValueForKey("segments")->GetAsArray(); 433 uint32_t segcount = segments->GetSize(); 434 for (size_t j = 0; j < segcount; j++) { 435 Segment segment; 436 StructuredData::Dictionary *seg = 437 segments->GetItemAtIndex(j)->GetAsDictionary(); 438 segment.name = 439 ConstString(seg->GetValueForKey("name")->GetAsString()->GetValue()); 440 segment.vmaddr = 441 seg->GetValueForKey("vmaddr")->GetAsInteger()->GetValue(); 442 segment.vmsize = 443 seg->GetValueForKey("vmsize")->GetAsInteger()->GetValue(); 444 segment.fileoff = 445 seg->GetValueForKey("fileoff")->GetAsInteger()->GetValue(); 446 segment.filesize = 447 seg->GetValueForKey("filesize")->GetAsInteger()->GetValue(); 448 segment.maxprot = 449 seg->GetValueForKey("maxprot")->GetAsInteger()->GetValue(); 450 451 // Fields that aren't used by DynamicLoaderDarwin so debugserver doesn't 452 // currently send them in the reply. 453 454 if (seg->HasKey("initprot")) 455 segment.initprot = 456 seg->GetValueForKey("initprot")->GetAsInteger()->GetValue(); 457 else 458 segment.initprot = 0; 459 460 if (seg->HasKey("flags")) 461 segment.flags = 462 seg->GetValueForKey("flags")->GetAsInteger()->GetValue(); 463 else 464 segment.flags = 0; 465 466 if (seg->HasKey("nsects")) 467 segment.nsects = 468 seg->GetValueForKey("nsects")->GetAsInteger()->GetValue(); 469 else 470 segment.nsects = 0; 471 472 image_infos[i].segments.push_back(segment); 473 } 474 475 image_infos[i].uuid.SetFromStringRef( 476 image->GetValueForKey("uuid")->GetAsString()->GetValue()); 477 478 // All sections listed in the dyld image info structure will all either be 479 // fixed up already, or they will all be off by a single slide amount that 480 // is determined by finding the first segment that is at file offset zero 481 // which also has bytes (a file size that is greater than zero) in the 482 // object file. 483 484 // Determine the slide amount (if any) 485 const size_t num_sections = image_infos[i].segments.size(); 486 for (size_t k = 0; k < num_sections; ++k) { 487 // Iterate through the object file sections to find the first section 488 // that starts of file offset zero and that has bytes in the file... 489 if ((image_infos[i].segments[k].fileoff == 0 && 490 image_infos[i].segments[k].filesize > 0) || 491 (image_infos[i].segments[k].name == ConstString("__TEXT"))) { 492 image_infos[i].slide = 493 image_infos[i].address - image_infos[i].segments[k].vmaddr; 494 // We have found the slide amount, so we can exit this for loop. 495 break; 496 } 497 } 498 } 499 500 return true; 501 } 502 503 void DynamicLoaderDarwin::UpdateSpecialBinariesFromNewImageInfos( 504 ImageInfo::collection &image_infos) { 505 uint32_t exe_idx = UINT32_MAX; 506 uint32_t dyld_idx = UINT32_MAX; 507 Target &target = m_process->GetTarget(); 508 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 509 ConstString g_dyld_sim_filename("dyld_sim"); 510 511 ArchSpec target_arch = target.GetArchitecture(); 512 const size_t image_infos_size = image_infos.size(); 513 for (size_t i = 0; i < image_infos_size; i++) { 514 if (image_infos[i].header.filetype == llvm::MachO::MH_DYLINKER) { 515 // In a "simulator" process (an x86 process that is ios/tvos/watchos) we 516 // will have two dyld modules -- a "dyld" that we want to keep track of, 517 // and a "dyld_sim" which we don't need to keep track of here. If the 518 // target is an x86 system and the OS of the dyld binary is 519 // ios/tvos/watchos, then we are looking at dyld_sym. 520 521 // debugserver has only recently (late 2016) started sending up the os 522 // type for each binary it sees -- so if we don't have an os type, use a 523 // filename check as our next best guess. 524 if (image_infos[i].os_type == llvm::Triple::OSType::UnknownOS) { 525 if (image_infos[i].file_spec.GetFilename() != g_dyld_sim_filename) { 526 dyld_idx = i; 527 } 528 } else if (target_arch.GetTriple().getArch() == llvm::Triple::x86 || 529 target_arch.GetTriple().getArch() == llvm::Triple::x86_64) { 530 if (image_infos[i].os_type != llvm::Triple::OSType::IOS && 531 image_infos[i].os_type != llvm::Triple::TvOS && 532 image_infos[i].os_type != llvm::Triple::WatchOS) { 533 dyld_idx = i; 534 } 535 } 536 else { 537 // catch-all for any other environment -- trust that dyld is actually 538 // dyld 539 dyld_idx = i; 540 } 541 } else if (image_infos[i].header.filetype == llvm::MachO::MH_EXECUTE) { 542 exe_idx = i; 543 } 544 } 545 546 if (exe_idx != UINT32_MAX) { 547 const bool can_create = true; 548 ModuleSP exe_module_sp( 549 FindTargetModuleForImageInfo(image_infos[exe_idx], can_create, NULL)); 550 if (exe_module_sp) { 551 if (log) 552 log->Printf("Found executable module: %s", 553 exe_module_sp->GetFileSpec().GetPath().c_str()); 554 target.GetImages().AppendIfNeeded(exe_module_sp); 555 UpdateImageLoadAddress(exe_module_sp.get(), image_infos[exe_idx]); 556 if (exe_module_sp.get() != target.GetExecutableModulePointer()) { 557 const bool get_dependent_images = false; 558 target.SetExecutableModule(exe_module_sp, get_dependent_images); 559 } 560 } 561 } 562 563 if (dyld_idx != UINT32_MAX) { 564 const bool can_create = true; 565 ModuleSP dyld_sp = 566 FindTargetModuleForImageInfo(image_infos[dyld_idx], can_create, NULL); 567 if (dyld_sp.get()) { 568 if (log) 569 log->Printf("Found dyld module: %s", 570 dyld_sp->GetFileSpec().GetPath().c_str()); 571 target.GetImages().AppendIfNeeded(dyld_sp); 572 UpdateImageLoadAddress(dyld_sp.get(), image_infos[dyld_idx]); 573 SetDYLDModule(dyld_sp); 574 } 575 } 576 } 577 578 void DynamicLoaderDarwin::UpdateDYLDImageInfoFromNewImageInfo( 579 ImageInfo &image_info) { 580 if (image_info.header.filetype == llvm::MachO::MH_DYLINKER) { 581 const bool can_create = true; 582 ModuleSP dyld_sp = 583 FindTargetModuleForImageInfo(image_info, can_create, NULL); 584 if (dyld_sp.get()) { 585 Target &target = m_process->GetTarget(); 586 target.GetImages().AppendIfNeeded(dyld_sp); 587 UpdateImageLoadAddress(dyld_sp.get(), image_info); 588 SetDYLDModule(dyld_sp); 589 } 590 } 591 } 592 593 void DynamicLoaderDarwin::SetDYLDModule(lldb::ModuleSP &dyld_module_sp) { 594 m_dyld_module_wp = dyld_module_sp; 595 } 596 597 ModuleSP DynamicLoaderDarwin::GetDYLDModule() { 598 ModuleSP dyld_sp(m_dyld_module_wp.lock()); 599 return dyld_sp; 600 } 601 602 bool DynamicLoaderDarwin::AddModulesUsingImageInfos( 603 ImageInfo::collection &image_infos) { 604 std::lock_guard<std::recursive_mutex> guard(m_mutex); 605 // Now add these images to the main list. 606 ModuleList loaded_module_list; 607 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 608 Target &target = m_process->GetTarget(); 609 ModuleList &target_images = target.GetImages(); 610 611 for (uint32_t idx = 0; idx < image_infos.size(); ++idx) { 612 if (log) { 613 log->Printf("Adding new image at address=0x%16.16" PRIx64 ".", 614 image_infos[idx].address); 615 image_infos[idx].PutToLog(log); 616 } 617 618 m_dyld_image_infos.push_back(image_infos[idx]); 619 620 ModuleSP image_module_sp( 621 FindTargetModuleForImageInfo(image_infos[idx], true, NULL)); 622 623 if (image_module_sp) { 624 ObjectFile *objfile = image_module_sp->GetObjectFile(); 625 if (objfile) { 626 SectionList *sections = objfile->GetSectionList(); 627 if (sections) { 628 ConstString commpage_dbstr("__commpage"); 629 Section *commpage_section = 630 sections->FindSectionByName(commpage_dbstr).get(); 631 if (commpage_section) { 632 ModuleSpec module_spec(objfile->GetFileSpec(), 633 image_infos[idx].GetArchitecture()); 634 module_spec.GetObjectName() = commpage_dbstr; 635 ModuleSP commpage_image_module_sp( 636 target_images.FindFirstModule(module_spec)); 637 if (!commpage_image_module_sp) { 638 module_spec.SetObjectOffset(objfile->GetFileOffset() + 639 commpage_section->GetFileOffset()); 640 module_spec.SetObjectSize(objfile->GetByteSize()); 641 commpage_image_module_sp = target.GetSharedModule(module_spec); 642 if (!commpage_image_module_sp || 643 commpage_image_module_sp->GetObjectFile() == NULL) { 644 commpage_image_module_sp = m_process->ReadModuleFromMemory( 645 image_infos[idx].file_spec, image_infos[idx].address); 646 // Always load a memory image right away in the target in case 647 // we end up trying to read the symbol table from memory... The 648 // __LINKEDIT will need to be mapped so we can figure out where 649 // the symbol table bits are... 650 bool changed = false; 651 UpdateImageLoadAddress(commpage_image_module_sp.get(), 652 image_infos[idx]); 653 target.GetImages().Append(commpage_image_module_sp); 654 if (changed) { 655 image_infos[idx].load_stop_id = m_process->GetStopID(); 656 loaded_module_list.AppendIfNeeded(commpage_image_module_sp); 657 } 658 } 659 } 660 } 661 } 662 } 663 664 // UpdateImageLoadAddress will return true if any segments change load 665 // address. We need to check this so we don't mention that all loaded 666 // shared libraries are newly loaded each time we hit out dyld breakpoint 667 // since dyld will list all shared libraries each time. 668 if (UpdateImageLoadAddress(image_module_sp.get(), image_infos[idx])) { 669 target_images.AppendIfNeeded(image_module_sp); 670 loaded_module_list.AppendIfNeeded(image_module_sp); 671 } 672 } 673 } 674 675 if (loaded_module_list.GetSize() > 0) { 676 if (log) 677 loaded_module_list.LogUUIDAndPaths(log, 678 "DynamicLoaderDarwin::ModulesDidLoad"); 679 m_process->GetTarget().ModulesDidLoad(loaded_module_list); 680 } 681 return true; 682 } 683 684 //---------------------------------------------------------------------- 685 // On Mac OS X libobjc (the Objective-C runtime) has several critical dispatch 686 // functions written in hand-written assembly, and also have hand-written 687 // unwind information in the eh_frame section. Normally we prefer analyzing 688 // the assembly instructions of a currently executing frame to unwind from that 689 // frame -- but on hand-written functions this profiling can fail. We should 690 // use the eh_frame instructions for these functions all the time. 691 // 692 // As an aside, it would be better if the eh_frame entries had a flag (or were 693 // extensible so they could have an Apple-specific flag) which indicates that 694 // the instructions are asynchronous -- accurate at every instruction, instead 695 // of our normal default assumption that they are not. 696 //---------------------------------------------------------------------- 697 698 bool DynamicLoaderDarwin::AlwaysRelyOnEHUnwindInfo(SymbolContext &sym_ctx) { 699 ModuleSP module_sp; 700 if (sym_ctx.symbol) { 701 module_sp = sym_ctx.symbol->GetAddressRef().GetModule(); 702 } 703 if (module_sp.get() == NULL && sym_ctx.function) { 704 module_sp = 705 sym_ctx.function->GetAddressRange().GetBaseAddress().GetModule(); 706 } 707 if (module_sp.get() == NULL) 708 return false; 709 710 ObjCLanguageRuntime *objc_runtime = m_process->GetObjCLanguageRuntime(); 711 if (objc_runtime != NULL && objc_runtime->IsModuleObjCLibrary(module_sp)) { 712 return true; 713 } 714 715 return false; 716 } 717 718 //---------------------------------------------------------------------- 719 // Dump a Segment to the file handle provided. 720 //---------------------------------------------------------------------- 721 void DynamicLoaderDarwin::Segment::PutToLog(Log *log, 722 lldb::addr_t slide) const { 723 if (log) { 724 if (slide == 0) 725 log->Printf("\t\t%16s [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ")", 726 name.AsCString(""), vmaddr + slide, vmaddr + slide + vmsize); 727 else 728 log->Printf("\t\t%16s [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 729 ") slide = 0x%" PRIx64, 730 name.AsCString(""), vmaddr + slide, vmaddr + slide + vmsize, 731 slide); 732 } 733 } 734 735 const DynamicLoaderDarwin::Segment * 736 DynamicLoaderDarwin::ImageInfo::FindSegment(const ConstString &name) const { 737 const size_t num_segments = segments.size(); 738 for (size_t i = 0; i < num_segments; ++i) { 739 if (segments[i].name == name) 740 return &segments[i]; 741 } 742 return NULL; 743 } 744 745 //---------------------------------------------------------------------- 746 // Dump an image info structure to the file handle provided. 747 //---------------------------------------------------------------------- 748 void DynamicLoaderDarwin::ImageInfo::PutToLog(Log *log) const { 749 if (log == NULL) 750 return; 751 const uint8_t *u = (const uint8_t *)uuid.GetBytes(); 752 753 if (address == LLDB_INVALID_ADDRESS) { 754 if (u) { 755 log->Printf("\t modtime=0x%8.8" PRIx64 756 " uuid=%2.2X%2.2X%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-" 757 "%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X path='%s' (UNLOADED)", 758 mod_date, u[0], u[1], u[2], u[3], u[4], u[5], u[6], u[7], 759 u[8], u[9], u[10], u[11], u[12], u[13], u[14], u[15], 760 file_spec.GetPath().c_str()); 761 } else 762 log->Printf("\t modtime=0x%8.8" PRIx64 763 " path='%s' (UNLOADED)", 764 mod_date, file_spec.GetPath().c_str()); 765 } else { 766 if (u) { 767 log->Printf("\taddress=0x%16.16" PRIx64 " modtime=0x%8.8" PRIx64 768 " uuid=%2.2X%2.2X%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-" 769 "%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X path='%s'", 770 address, mod_date, u[0], u[1], u[2], u[3], u[4], u[5], u[6], 771 u[7], u[8], u[9], u[10], u[11], u[12], u[13], u[14], u[15], 772 file_spec.GetPath().c_str()); 773 } else { 774 log->Printf("\taddress=0x%16.16" PRIx64 " modtime=0x%8.8" PRIx64 775 " path='%s'", 776 address, mod_date, file_spec.GetPath().c_str()); 777 } 778 for (uint32_t i = 0; i < segments.size(); ++i) 779 segments[i].PutToLog(log, slide); 780 } 781 } 782 783 void DynamicLoaderDarwin::PrivateInitialize(Process *process) { 784 DEBUG_PRINTF("DynamicLoaderDarwin::%s() process state = %s\n", __FUNCTION__, 785 StateAsCString(m_process->GetState())); 786 Clear(true); 787 m_process = process; 788 m_process->GetTarget().ClearAllLoadedSections(); 789 } 790 791 //---------------------------------------------------------------------- 792 // Member function that gets called when the process state changes. 793 //---------------------------------------------------------------------- 794 void DynamicLoaderDarwin::PrivateProcessStateChanged(Process *process, 795 StateType state) { 796 DEBUG_PRINTF("DynamicLoaderDarwin::%s(%s)\n", __FUNCTION__, 797 StateAsCString(state)); 798 switch (state) { 799 case eStateConnected: 800 case eStateAttaching: 801 case eStateLaunching: 802 case eStateInvalid: 803 case eStateUnloaded: 804 case eStateExited: 805 case eStateDetached: 806 Clear(false); 807 break; 808 809 case eStateStopped: 810 // Keep trying find dyld and set our notification breakpoint each time we 811 // stop until we succeed 812 if (!DidSetNotificationBreakpoint() && m_process->IsAlive()) { 813 if (NeedToDoInitialImageFetch()) 814 DoInitialImageFetch(); 815 816 SetNotificationBreakpoint(); 817 } 818 break; 819 820 case eStateRunning: 821 case eStateStepping: 822 case eStateCrashed: 823 case eStateSuspended: 824 break; 825 } 826 } 827 828 ThreadPlanSP 829 DynamicLoaderDarwin::GetStepThroughTrampolinePlan(Thread &thread, 830 bool stop_others) { 831 ThreadPlanSP thread_plan_sp; 832 StackFrame *current_frame = thread.GetStackFrameAtIndex(0).get(); 833 const SymbolContext ¤t_context = 834 current_frame->GetSymbolContext(eSymbolContextSymbol); 835 Symbol *current_symbol = current_context.symbol; 836 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); 837 TargetSP target_sp(thread.CalculateTarget()); 838 839 if (current_symbol != NULL) { 840 std::vector<Address> addresses; 841 842 if (current_symbol->IsTrampoline()) { 843 const ConstString &trampoline_name = current_symbol->GetMangled().GetName( 844 current_symbol->GetLanguage(), Mangled::ePreferMangled); 845 846 if (trampoline_name) { 847 const ModuleList &images = target_sp->GetImages(); 848 849 SymbolContextList code_symbols; 850 images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeCode, 851 code_symbols); 852 size_t num_code_symbols = code_symbols.GetSize(); 853 854 if (num_code_symbols > 0) { 855 for (uint32_t i = 0; i < num_code_symbols; i++) { 856 SymbolContext context; 857 AddressRange addr_range; 858 if (code_symbols.GetContextAtIndex(i, context)) { 859 context.GetAddressRange(eSymbolContextEverything, 0, false, 860 addr_range); 861 addresses.push_back(addr_range.GetBaseAddress()); 862 if (log) { 863 addr_t load_addr = 864 addr_range.GetBaseAddress().GetLoadAddress(target_sp.get()); 865 866 log->Printf("Found a trampoline target symbol at 0x%" PRIx64 867 ".", 868 load_addr); 869 } 870 } 871 } 872 } 873 874 SymbolContextList reexported_symbols; 875 images.FindSymbolsWithNameAndType( 876 trampoline_name, eSymbolTypeReExported, reexported_symbols); 877 size_t num_reexported_symbols = reexported_symbols.GetSize(); 878 if (num_reexported_symbols > 0) { 879 for (uint32_t i = 0; i < num_reexported_symbols; i++) { 880 SymbolContext context; 881 if (reexported_symbols.GetContextAtIndex(i, context)) { 882 if (context.symbol) { 883 Symbol *actual_symbol = 884 context.symbol->ResolveReExportedSymbol(*target_sp.get()); 885 if (actual_symbol) { 886 const Address actual_symbol_addr = 887 actual_symbol->GetAddress(); 888 if (actual_symbol_addr.IsValid()) { 889 addresses.push_back(actual_symbol_addr); 890 if (log) { 891 lldb::addr_t load_addr = 892 actual_symbol_addr.GetLoadAddress(target_sp.get()); 893 log->Printf( 894 "Found a re-exported symbol: %s at 0x%" PRIx64 ".", 895 actual_symbol->GetName().GetCString(), load_addr); 896 } 897 } 898 } 899 } 900 } 901 } 902 } 903 904 SymbolContextList indirect_symbols; 905 images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeResolver, 906 indirect_symbols); 907 size_t num_indirect_symbols = indirect_symbols.GetSize(); 908 if (num_indirect_symbols > 0) { 909 for (uint32_t i = 0; i < num_indirect_symbols; i++) { 910 SymbolContext context; 911 AddressRange addr_range; 912 if (indirect_symbols.GetContextAtIndex(i, context)) { 913 context.GetAddressRange(eSymbolContextEverything, 0, false, 914 addr_range); 915 addresses.push_back(addr_range.GetBaseAddress()); 916 if (log) { 917 addr_t load_addr = 918 addr_range.GetBaseAddress().GetLoadAddress(target_sp.get()); 919 920 log->Printf("Found an indirect target symbol at 0x%" PRIx64 ".", 921 load_addr); 922 } 923 } 924 } 925 } 926 } 927 } else if (current_symbol->GetType() == eSymbolTypeReExported) { 928 // I am not sure we could ever end up stopped AT a re-exported symbol. 929 // But just in case: 930 931 const Symbol *actual_symbol = 932 current_symbol->ResolveReExportedSymbol(*(target_sp.get())); 933 if (actual_symbol) { 934 Address target_addr(actual_symbol->GetAddress()); 935 if (target_addr.IsValid()) { 936 if (log) 937 log->Printf( 938 "Found a re-exported symbol: %s pointing to: %s at 0x%" PRIx64 939 ".", 940 current_symbol->GetName().GetCString(), 941 actual_symbol->GetName().GetCString(), 942 target_addr.GetLoadAddress(target_sp.get())); 943 addresses.push_back(target_addr.GetLoadAddress(target_sp.get())); 944 } 945 } 946 } 947 948 if (addresses.size() > 0) { 949 // First check whether any of the addresses point to Indirect symbols, 950 // and if they do, resolve them: 951 std::vector<lldb::addr_t> load_addrs; 952 for (Address address : addresses) { 953 Symbol *symbol = address.CalculateSymbolContextSymbol(); 954 if (symbol && symbol->IsIndirect()) { 955 Status error; 956 Address symbol_address = symbol->GetAddress(); 957 addr_t resolved_addr = thread.GetProcess()->ResolveIndirectFunction( 958 &symbol_address, error); 959 if (error.Success()) { 960 load_addrs.push_back(resolved_addr); 961 if (log) 962 log->Printf("ResolveIndirectFunction found resolved target for " 963 "%s at 0x%" PRIx64 ".", 964 symbol->GetName().GetCString(), resolved_addr); 965 } 966 } else { 967 load_addrs.push_back(address.GetLoadAddress(target_sp.get())); 968 } 969 } 970 thread_plan_sp.reset( 971 new ThreadPlanRunToAddress(thread, load_addrs, stop_others)); 972 } 973 } else { 974 if (log) 975 log->Printf("Could not find symbol for step through."); 976 } 977 978 return thread_plan_sp; 979 } 980 981 size_t DynamicLoaderDarwin::FindEquivalentSymbols( 982 lldb_private::Symbol *original_symbol, lldb_private::ModuleList &images, 983 lldb_private::SymbolContextList &equivalent_symbols) { 984 const ConstString &trampoline_name = original_symbol->GetMangled().GetName( 985 original_symbol->GetLanguage(), Mangled::ePreferMangled); 986 if (!trampoline_name) 987 return 0; 988 989 size_t initial_size = equivalent_symbols.GetSize(); 990 991 static const char *resolver_name_regex = "(_gc|_non_gc|\\$[A-Za-z0-9\\$]+)$"; 992 std::string equivalent_regex_buf("^"); 993 equivalent_regex_buf.append(trampoline_name.GetCString()); 994 equivalent_regex_buf.append(resolver_name_regex); 995 996 RegularExpression equivalent_name_regex(equivalent_regex_buf); 997 const bool append = true; 998 images.FindSymbolsMatchingRegExAndType(equivalent_name_regex, eSymbolTypeCode, 999 equivalent_symbols, append); 1000 1001 return equivalent_symbols.GetSize() - initial_size; 1002 } 1003 1004 lldb::ModuleSP DynamicLoaderDarwin::GetPThreadLibraryModule() { 1005 ModuleSP module_sp = m_libpthread_module_wp.lock(); 1006 if (!module_sp) { 1007 SymbolContextList sc_list; 1008 ModuleSpec module_spec; 1009 module_spec.GetFileSpec().GetFilename().SetCString( 1010 "libsystem_pthread.dylib"); 1011 ModuleList module_list; 1012 if (m_process->GetTarget().GetImages().FindModules(module_spec, 1013 module_list)) { 1014 if (module_list.GetSize() == 1) { 1015 module_sp = module_list.GetModuleAtIndex(0); 1016 if (module_sp) 1017 m_libpthread_module_wp = module_sp; 1018 } 1019 } 1020 } 1021 return module_sp; 1022 } 1023 1024 Address DynamicLoaderDarwin::GetPthreadSetSpecificAddress() { 1025 if (!m_pthread_getspecific_addr.IsValid()) { 1026 ModuleSP module_sp = GetPThreadLibraryModule(); 1027 if (module_sp) { 1028 lldb_private::SymbolContextList sc_list; 1029 module_sp->FindSymbolsWithNameAndType(ConstString("pthread_getspecific"), 1030 eSymbolTypeCode, sc_list); 1031 SymbolContext sc; 1032 if (sc_list.GetContextAtIndex(0, sc)) { 1033 if (sc.symbol) 1034 m_pthread_getspecific_addr = sc.symbol->GetAddress(); 1035 } 1036 } 1037 } 1038 return m_pthread_getspecific_addr; 1039 } 1040 1041 lldb::addr_t 1042 DynamicLoaderDarwin::GetThreadLocalData(const lldb::ModuleSP module_sp, 1043 const lldb::ThreadSP thread_sp, 1044 lldb::addr_t tls_file_addr) { 1045 if (!thread_sp || !module_sp) 1046 return LLDB_INVALID_ADDRESS; 1047 1048 std::lock_guard<std::recursive_mutex> guard(m_mutex); 1049 1050 const uint32_t addr_size = m_process->GetAddressByteSize(); 1051 uint8_t buf[sizeof(lldb::addr_t) * 3]; 1052 1053 lldb_private::Address tls_addr; 1054 if (module_sp->ResolveFileAddress(tls_file_addr, tls_addr)) { 1055 Status error; 1056 const size_t tsl_data_size = addr_size * 3; 1057 Target &target = m_process->GetTarget(); 1058 if (target.ReadMemory(tls_addr, false, buf, tsl_data_size, error) == 1059 tsl_data_size) { 1060 const ByteOrder byte_order = m_process->GetByteOrder(); 1061 DataExtractor data(buf, sizeof(buf), byte_order, addr_size); 1062 lldb::offset_t offset = addr_size; // Skip the first pointer 1063 const lldb::addr_t pthread_key = data.GetAddress(&offset); 1064 const lldb::addr_t tls_offset = data.GetAddress(&offset); 1065 if (pthread_key != 0) { 1066 // First check to see if we have already figured out the location of 1067 // TLS data for the pthread_key on a specific thread yet. If we have we 1068 // can re-use it since its location will not change unless the process 1069 // execs. 1070 const tid_t tid = thread_sp->GetID(); 1071 auto tid_pos = m_tid_to_tls_map.find(tid); 1072 if (tid_pos != m_tid_to_tls_map.end()) { 1073 auto tls_pos = tid_pos->second.find(pthread_key); 1074 if (tls_pos != tid_pos->second.end()) { 1075 return tls_pos->second + tls_offset; 1076 } 1077 } 1078 StackFrameSP frame_sp = thread_sp->GetStackFrameAtIndex(0); 1079 if (frame_sp) { 1080 ClangASTContext *clang_ast_context = 1081 target.GetScratchClangASTContext(); 1082 1083 if (!clang_ast_context) 1084 return LLDB_INVALID_ADDRESS; 1085 1086 CompilerType clang_void_ptr_type = 1087 clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType(); 1088 Address pthread_getspecific_addr = GetPthreadSetSpecificAddress(); 1089 if (pthread_getspecific_addr.IsValid()) { 1090 EvaluateExpressionOptions options; 1091 1092 lldb::ThreadPlanSP thread_plan_sp(new ThreadPlanCallFunction( 1093 *thread_sp, pthread_getspecific_addr, clang_void_ptr_type, 1094 llvm::ArrayRef<lldb::addr_t>(pthread_key), options)); 1095 1096 DiagnosticManager execution_errors; 1097 ExecutionContext exe_ctx(thread_sp); 1098 lldb::ExpressionResults results = m_process->RunThreadPlan( 1099 exe_ctx, thread_plan_sp, options, execution_errors); 1100 1101 if (results == lldb::eExpressionCompleted) { 1102 lldb::ValueObjectSP result_valobj_sp = 1103 thread_plan_sp->GetReturnValueObject(); 1104 if (result_valobj_sp) { 1105 const lldb::addr_t pthread_key_data = 1106 result_valobj_sp->GetValueAsUnsigned(0); 1107 if (pthread_key_data) { 1108 m_tid_to_tls_map[tid].insert( 1109 std::make_pair(pthread_key, pthread_key_data)); 1110 return pthread_key_data + tls_offset; 1111 } 1112 } 1113 } 1114 } 1115 } 1116 } 1117 } 1118 } 1119 return LLDB_INVALID_ADDRESS; 1120 } 1121 1122 bool DynamicLoaderDarwin::UseDYLDSPI(Process *process) { 1123 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 1124 uint32_t major, minor, update; 1125 1126 bool use_new_spi_interface = false; 1127 1128 if (process->GetHostOSVersion(major, minor, update)) { 1129 const llvm::Triple::OSType os_type = 1130 process->GetTarget().GetArchitecture().GetTriple().getOS(); 1131 1132 // macOS 10.12 and newer 1133 if (os_type == llvm::Triple::MacOSX && 1134 (major > 10 || (major == 10 && minor >= 12))) { 1135 use_new_spi_interface = true; 1136 } 1137 1138 // iOS 10 and newer 1139 if (os_type == llvm::Triple::IOS && major >= 10) { 1140 use_new_spi_interface = true; 1141 } 1142 1143 // tvOS 10 and newer 1144 if (os_type == llvm::Triple::TvOS && major >= 10) { 1145 use_new_spi_interface = true; 1146 } 1147 1148 // watchOS 3 and newer 1149 if (os_type == llvm::Triple::WatchOS && major >= 3) { 1150 use_new_spi_interface = true; 1151 } 1152 } 1153 1154 if (log) { 1155 if (use_new_spi_interface) 1156 log->Printf( 1157 "DynamicLoaderDarwin::UseDYLDSPI: Use new DynamicLoader plugin"); 1158 else 1159 log->Printf( 1160 "DynamicLoaderDarwin::UseDYLDSPI: Use old DynamicLoader plugin"); 1161 } 1162 return use_new_spi_interface; 1163 } 1164