1 //===-- PlatformRemoteAppleTV.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 // C Includes 11 // C++ Includes 12 #include <string> 13 #include <vector> 14 15 // Other libraries and framework includes 16 // Project includes 17 #include "PlatformRemoteAppleTV.h" 18 19 #include "lldb/Breakpoint/BreakpointLocation.h" 20 #include "lldb/Core/ArchSpec.h" 21 #include "lldb/Core/Error.h" 22 #include "lldb/Core/Log.h" 23 #include "lldb/Core/Module.h" 24 #include "lldb/Core/ModuleList.h" 25 #include "lldb/Core/ModuleSpec.h" 26 #include "lldb/Core/PluginManager.h" 27 #include "lldb/Core/StreamString.h" 28 #include "lldb/Host/FileSpec.h" 29 #include "lldb/Host/Host.h" 30 #include "lldb/Target/Process.h" 31 #include "lldb/Target/Target.h" 32 33 using namespace lldb; 34 using namespace lldb_private; 35 36 //------------------------------------------------------------------ 37 /// Default Constructor 38 //------------------------------------------------------------------ 39 PlatformRemoteAppleTV::PlatformRemoteAppleTV () : 40 PlatformDarwin (false), // This is a remote platform 41 m_sdk_directory_infos(), 42 m_device_support_directory(), 43 m_device_support_directory_for_os_version (), 44 m_build_update(), 45 m_last_module_sdk_idx (UINT32_MAX), 46 m_connected_module_sdk_idx (UINT32_MAX) 47 { 48 } 49 50 PlatformRemoteAppleTV::SDKDirectoryInfo::SDKDirectoryInfo (const lldb_private::FileSpec &sdk_dir) : 51 directory(sdk_dir), 52 build(), 53 version_major(0), 54 version_minor(0), 55 version_update(0), 56 user_cached(false) 57 { 58 const char *dirname_cstr = sdk_dir.GetFilename().GetCString(); 59 const char *pos = Args::StringToVersion (dirname_cstr, 60 version_major, 61 version_minor, 62 version_update); 63 64 if (pos && pos[0] == ' ' && pos[1] == '(') 65 { 66 const char *build_start = pos + 2; 67 const char *end_paren = strchr (build_start, ')'); 68 if (end_paren && build_start < end_paren) 69 build.SetCStringWithLength(build_start, end_paren - build_start); 70 } 71 } 72 73 //------------------------------------------------------------------ 74 // Static Variables 75 //------------------------------------------------------------------ 76 static uint32_t g_initialize_count = 0; 77 78 //------------------------------------------------------------------ 79 // Static Functions 80 //------------------------------------------------------------------ 81 void 82 PlatformRemoteAppleTV::Initialize () 83 { 84 PlatformDarwin::Initialize (); 85 86 if (g_initialize_count++ == 0) 87 { 88 PluginManager::RegisterPlugin (PlatformRemoteAppleTV::GetPluginNameStatic(), 89 PlatformRemoteAppleTV::GetDescriptionStatic(), 90 PlatformRemoteAppleTV::CreateInstance); 91 } 92 } 93 94 void 95 PlatformRemoteAppleTV::Terminate () 96 { 97 if (g_initialize_count > 0) 98 { 99 if (--g_initialize_count == 0) 100 { 101 PluginManager::UnregisterPlugin (PlatformRemoteAppleTV::CreateInstance); 102 } 103 } 104 105 PlatformDarwin::Terminate (); 106 } 107 108 PlatformSP 109 PlatformRemoteAppleTV::CreateInstance (bool force, const ArchSpec *arch) 110 { 111 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM)); 112 if (log) 113 { 114 const char *arch_name; 115 if (arch && arch->GetArchitectureName ()) 116 arch_name = arch->GetArchitectureName (); 117 else 118 arch_name = "<null>"; 119 120 const char *triple_cstr = arch ? arch->GetTriple ().getTriple ().c_str() : "<null>"; 121 122 log->Printf ("PlatformRemoteAppleTV::%s(force=%s, arch={%s,%s})", __FUNCTION__, force ? "true" : "false", arch_name, triple_cstr); 123 } 124 125 bool create = force; 126 if (!create && arch && arch->IsValid()) 127 { 128 switch (arch->GetMachine()) 129 { 130 case llvm::Triple::arm: 131 case llvm::Triple::aarch64: 132 case llvm::Triple::thumb: 133 { 134 const llvm::Triple &triple = arch->GetTriple(); 135 llvm::Triple::VendorType vendor = triple.getVendor(); 136 switch (vendor) 137 { 138 case llvm::Triple::Apple: 139 create = true; 140 break; 141 142 #if defined(__APPLE__) 143 // Only accept "unknown" for the vendor if the host is Apple and 144 // it "unknown" wasn't specified (it was just returned because it 145 // was NOT specified) 146 case llvm::Triple::UnknownArch: 147 create = !arch->TripleVendorWasSpecified(); 148 break; 149 150 #endif 151 default: 152 break; 153 } 154 if (create) 155 { 156 switch (triple.getOS()) 157 { 158 case llvm::Triple::TvOS: // This is the right triple value for Apple TV debugging 159 break; 160 161 #if defined(__APPLE__) 162 // Only accept "unknown" for the OS if the host is Apple and 163 // it "unknown" wasn't specified (it was just returned because it 164 // was NOT specified) 165 case llvm::Triple::UnknownOS: 166 create = !arch->TripleOSWasSpecified(); 167 break; 168 #endif 169 default: 170 create = false; 171 break; 172 } 173 } 174 } 175 break; 176 default: 177 break; 178 } 179 } 180 181 if (create) 182 { 183 if (log) 184 log->Printf ("PlatformRemoteAppleTV::%s() creating platform", __FUNCTION__); 185 186 return lldb::PlatformSP(new PlatformRemoteAppleTV ()); 187 } 188 189 if (log) 190 log->Printf ("PlatformRemoteAppleTV::%s() aborting creation of platform", __FUNCTION__); 191 192 return lldb::PlatformSP(); 193 } 194 195 lldb_private::ConstString 196 PlatformRemoteAppleTV::GetPluginNameStatic () 197 { 198 static ConstString g_name("remote-tvos"); 199 return g_name; 200 } 201 202 const char * 203 PlatformRemoteAppleTV::GetDescriptionStatic() 204 { 205 return "Remote Apple TV platform plug-in."; 206 } 207 208 void 209 PlatformRemoteAppleTV::GetStatus (Stream &strm) 210 { 211 Platform::GetStatus (strm); 212 const char *sdk_directory = GetDeviceSupportDirectoryForOSVersion(); 213 if (sdk_directory) 214 strm.Printf (" SDK Path: \"%s\"\n", sdk_directory); 215 else 216 strm.PutCString (" SDK Path: error: unable to locate SDK\n"); 217 218 const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); 219 for (uint32_t i=0; i<num_sdk_infos; ++i) 220 { 221 const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[i]; 222 strm.Printf (" SDK Roots: [%2u] \"%s\"\n", 223 i, 224 sdk_dir_info.directory.GetPath().c_str()); 225 } 226 } 227 228 Error 229 PlatformRemoteAppleTV::ResolveExecutable (const ModuleSpec &ms, 230 lldb::ModuleSP &exe_module_sp, 231 const FileSpecList *module_search_paths_ptr) 232 { 233 Error error; 234 // Nothing special to do here, just use the actual file and architecture 235 236 ModuleSpec resolved_module_spec(ms); 237 238 // Resolve any executable within a bundle on MacOSX 239 // TODO: verify that this handles shallow bundles, if not then implement one ourselves 240 Host::ResolveExecutableInBundle (resolved_module_spec.GetFileSpec()); 241 242 if (resolved_module_spec.GetFileSpec().Exists()) 243 { 244 if (resolved_module_spec.GetArchitecture().IsValid() || resolved_module_spec.GetUUID().IsValid()) 245 { 246 error = ModuleList::GetSharedModule(resolved_module_spec, 247 exe_module_sp, 248 nullptr, 249 nullptr, 250 nullptr); 251 252 if (exe_module_sp && exe_module_sp->GetObjectFile()) 253 return error; 254 exe_module_sp.reset(); 255 } 256 // No valid architecture was specified or the exact ARM slice wasn't 257 // found so ask the platform for the architectures that we should be 258 // using (in the correct order) and see if we can find a match that way 259 StreamString arch_names; 260 for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, resolved_module_spec.GetArchitecture()); ++idx) 261 { 262 error = ModuleList::GetSharedModule(resolved_module_spec, 263 exe_module_sp, 264 nullptr, 265 nullptr, 266 nullptr); 267 // Did we find an executable using one of the 268 if (error.Success()) 269 { 270 if (exe_module_sp && exe_module_sp->GetObjectFile()) 271 break; 272 else 273 error.SetErrorToGenericError(); 274 } 275 276 if (idx > 0) 277 arch_names.PutCString (", "); 278 arch_names.PutCString (resolved_module_spec.GetArchitecture().GetArchitectureName()); 279 } 280 281 if (error.Fail() || !exe_module_sp) 282 { 283 if (resolved_module_spec.GetFileSpec().Readable()) 284 { 285 error.SetErrorStringWithFormat ("'%s' doesn't contain any '%s' platform architectures: %s", 286 resolved_module_spec.GetFileSpec().GetPath().c_str(), 287 GetPluginName().GetCString(), 288 arch_names.GetString().c_str()); 289 } 290 else 291 { 292 error.SetErrorStringWithFormat("'%s' is not readable", resolved_module_spec.GetFileSpec().GetPath().c_str()); 293 } 294 } 295 } 296 else 297 { 298 error.SetErrorStringWithFormat ("'%s' does not exist", 299 resolved_module_spec.GetFileSpec().GetPath().c_str()); 300 } 301 302 return error; 303 } 304 305 FileSpec::EnumerateDirectoryResult 306 PlatformRemoteAppleTV::GetContainedFilesIntoVectorOfStringsCallback (void *baton, 307 FileSpec::FileType file_type, 308 const FileSpec &file_spec) 309 { 310 ((PlatformRemoteAppleTV::SDKDirectoryInfoCollection *)baton)->push_back(PlatformRemoteAppleTV::SDKDirectoryInfo(file_spec)); 311 return FileSpec::eEnumerateDirectoryResultNext; 312 } 313 314 bool 315 PlatformRemoteAppleTV::UpdateSDKDirectoryInfosIfNeeded() 316 { 317 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST); 318 if (m_sdk_directory_infos.empty()) 319 { 320 const char *device_support_dir = GetDeviceSupportDirectory(); 321 if (log) 322 { 323 log->Printf ("PlatformRemoteAppleTV::UpdateSDKDirectoryInfosIfNeeded Got DeviceSupport directory %s", device_support_dir); 324 } 325 if (device_support_dir) 326 { 327 const bool find_directories = true; 328 const bool find_files = false; 329 const bool find_other = false; 330 331 SDKDirectoryInfoCollection builtin_sdk_directory_infos; 332 FileSpec::EnumerateDirectory (m_device_support_directory.c_str(), 333 find_directories, 334 find_files, 335 find_other, 336 GetContainedFilesIntoVectorOfStringsCallback, 337 &builtin_sdk_directory_infos); 338 339 // Only add SDK directories that have symbols in them, some SDKs only contain 340 // developer disk images and no symbols, so they aren't useful to us. 341 FileSpec sdk_symbols_symlink_fspec; 342 for (const auto &sdk_directory_info : builtin_sdk_directory_infos) 343 { 344 sdk_symbols_symlink_fspec = sdk_directory_info.directory; 345 sdk_symbols_symlink_fspec.AppendPathComponent("Symbols.Internal"); 346 if (sdk_symbols_symlink_fspec.Exists()) 347 { 348 m_sdk_directory_infos.push_back(sdk_directory_info); 349 if (log) 350 { 351 log->Printf ("PlatformRemoteAppleTV::UpdateSDKDirectoryInfosIfNeeded added builtin SDK directory %s", sdk_symbols_symlink_fspec.GetPath().c_str()); 352 } 353 } 354 else 355 { 356 sdk_symbols_symlink_fspec.GetFilename().SetCString("Symbols"); 357 if (sdk_symbols_symlink_fspec.Exists()) 358 m_sdk_directory_infos.push_back(sdk_directory_info); 359 if (log) 360 { 361 log->Printf ("PlatformRemoteAppleTV::UpdateSDKDirectoryInfosIfNeeded added builtin SDK directory %s", sdk_symbols_symlink_fspec.GetPath().c_str()); 362 } 363 } 364 } 365 366 const uint32_t num_installed = m_sdk_directory_infos.size(); 367 FileSpec local_sdk_cache("~/Library/Developer/Xcode/tvOS DeviceSupport", true); 368 if (!local_sdk_cache.Exists()) 369 { 370 // Try looking for another possible name 371 local_sdk_cache = FileSpec("~/Library/Developer/Xcode/Apple TVOS DeviceSupport", true); 372 } 373 if (!local_sdk_cache.Exists()) 374 { 375 // Try looking for another possible name 376 local_sdk_cache = FileSpec("~/Library/Developer/Xcode/AppleTVOS DeviceSupport", true); 377 } 378 if (!local_sdk_cache.Exists()) 379 { 380 // Try looking for another possible name 381 local_sdk_cache = FileSpec("~/Library/Developer/Xcode/AppleTV OS DeviceSupport", true); 382 } 383 if (!local_sdk_cache.Exists()) 384 { 385 // Try looking for another possible name 386 local_sdk_cache = FileSpec("~/Library/Developer/Xcode/Apple TV OS DeviceSupport", true); 387 } 388 if (local_sdk_cache.Exists()) 389 { 390 if (log) 391 { 392 log->Printf ("PlatformRemoteAppleTV::UpdateSDKDirectoryInfosIfNeeded searching %s for additional SDKs", local_sdk_cache.GetPath().c_str()); 393 } 394 char path[PATH_MAX]; 395 if (local_sdk_cache.GetPath(path, sizeof(path))) 396 { 397 FileSpec::EnumerateDirectory (path, 398 find_directories, 399 find_files, 400 find_other, 401 GetContainedFilesIntoVectorOfStringsCallback, 402 &m_sdk_directory_infos); 403 const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); 404 // First try for an exact match of major, minor and update 405 for (uint32_t i=num_installed; i<num_sdk_infos; ++i) 406 { 407 m_sdk_directory_infos[i].user_cached = true; 408 if (log) 409 { 410 log->Printf ("PlatformRemoteAppleTV::UpdateSDKDirectoryInfosIfNeeded user SDK directory %s", m_sdk_directory_infos[i].directory.GetPath().c_str()); 411 } 412 } 413 } 414 } 415 } 416 } 417 return !m_sdk_directory_infos.empty(); 418 } 419 420 const PlatformRemoteAppleTV::SDKDirectoryInfo * 421 PlatformRemoteAppleTV::GetSDKDirectoryForCurrentOSVersion () 422 { 423 uint32_t i; 424 if (UpdateSDKDirectoryInfosIfNeeded()) 425 { 426 const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); 427 428 // Check to see if the user specified a build string. If they did, then 429 // be sure to match it. 430 std::vector<bool> check_sdk_info(num_sdk_infos, true); 431 ConstString build(m_sdk_build); 432 if (build) 433 { 434 for (i=0; i<num_sdk_infos; ++i) 435 check_sdk_info[i] = m_sdk_directory_infos[i].build == build; 436 } 437 438 // If we are connected we can find the version of the OS the platform 439 // us running on and select the right SDK 440 uint32_t major, minor, update; 441 if (GetOSVersion(major, minor, update)) 442 { 443 if (UpdateSDKDirectoryInfosIfNeeded()) 444 { 445 // First try for an exact match of major, minor and update 446 for (i=0; i<num_sdk_infos; ++i) 447 { 448 if (check_sdk_info[i]) 449 { 450 if (m_sdk_directory_infos[i].version_major == major && 451 m_sdk_directory_infos[i].version_minor == minor && 452 m_sdk_directory_infos[i].version_update == update) 453 { 454 return &m_sdk_directory_infos[i]; 455 } 456 } 457 } 458 // First try for an exact match of major and minor 459 for (i=0; i<num_sdk_infos; ++i) 460 { 461 if (check_sdk_info[i]) 462 { 463 if (m_sdk_directory_infos[i].version_major == major && 464 m_sdk_directory_infos[i].version_minor == minor) 465 { 466 return &m_sdk_directory_infos[i]; 467 } 468 } 469 } 470 // Lastly try to match of major version only.. 471 for (i=0; i<num_sdk_infos; ++i) 472 { 473 if (check_sdk_info[i]) 474 { 475 if (m_sdk_directory_infos[i].version_major == major) 476 { 477 return &m_sdk_directory_infos[i]; 478 } 479 } 480 } 481 } 482 } 483 else if (build) 484 { 485 // No version, just a build number, search for the first one that matches 486 for (i=0; i<num_sdk_infos; ++i) 487 if (check_sdk_info[i]) 488 return &m_sdk_directory_infos[i]; 489 } 490 } 491 return nullptr; 492 } 493 494 const PlatformRemoteAppleTV::SDKDirectoryInfo * 495 PlatformRemoteAppleTV::GetSDKDirectoryForLatestOSVersion () 496 { 497 const PlatformRemoteAppleTV::SDKDirectoryInfo *result = nullptr; 498 if (UpdateSDKDirectoryInfosIfNeeded()) 499 { 500 const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); 501 // First try for an exact match of major, minor and update 502 for (uint32_t i=0; i<num_sdk_infos; ++i) 503 { 504 const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[i]; 505 if (sdk_dir_info.version_major != UINT32_MAX) 506 { 507 if (result == nullptr || sdk_dir_info.version_major > result->version_major) 508 { 509 result = &sdk_dir_info; 510 } 511 else if (sdk_dir_info.version_major == result->version_major) 512 { 513 if (sdk_dir_info.version_minor > result->version_minor) 514 { 515 result = &sdk_dir_info; 516 } 517 else if (sdk_dir_info.version_minor == result->version_minor) 518 { 519 if (sdk_dir_info.version_update > result->version_update) 520 { 521 result = &sdk_dir_info; 522 } 523 } 524 } 525 } 526 } 527 } 528 return result; 529 } 530 531 const char * 532 PlatformRemoteAppleTV::GetDeviceSupportDirectory() 533 { 534 if (m_device_support_directory.empty()) 535 { 536 const char *device_support_dir = GetDeveloperDirectory(); 537 if (device_support_dir) 538 { 539 m_device_support_directory.assign (device_support_dir); 540 m_device_support_directory.append ("/Platforms/AppleTVOS.platform/DeviceSupport"); 541 } 542 else 543 { 544 // Assign a single NULL character so we know we tried to find the device 545 // support directory and we don't keep trying to find it over and over. 546 m_device_support_directory.assign (1, '\0'); 547 } 548 } 549 // We should have put a single NULL character into m_device_support_directory 550 // or it should have a valid path if the code gets here 551 assert (m_device_support_directory.empty() == false); 552 if (m_device_support_directory[0]) 553 return m_device_support_directory.c_str(); 554 return nullptr; 555 } 556 557 const char * 558 PlatformRemoteAppleTV::GetDeviceSupportDirectoryForOSVersion() 559 { 560 if (m_sdk_sysroot) 561 return m_sdk_sysroot.GetCString(); 562 563 if (m_device_support_directory_for_os_version.empty()) 564 { 565 const PlatformRemoteAppleTV::SDKDirectoryInfo *sdk_dir_info = GetSDKDirectoryForCurrentOSVersion (); 566 if (sdk_dir_info == nullptr) 567 sdk_dir_info = GetSDKDirectoryForLatestOSVersion (); 568 if (sdk_dir_info) 569 { 570 char path[PATH_MAX]; 571 if (sdk_dir_info->directory.GetPath(path, sizeof(path))) 572 { 573 m_device_support_directory_for_os_version = path; 574 return m_device_support_directory_for_os_version.c_str(); 575 } 576 } 577 else 578 { 579 // Assign a single NULL character so we know we tried to find the device 580 // support directory and we don't keep trying to find it over and over. 581 m_device_support_directory_for_os_version.assign (1, '\0'); 582 } 583 } 584 // We should have put a single NULL character into m_device_support_directory_for_os_version 585 // or it should have a valid path if the code gets here 586 assert (m_device_support_directory_for_os_version.empty() == false); 587 if (m_device_support_directory_for_os_version[0]) 588 return m_device_support_directory_for_os_version.c_str(); 589 return nullptr; 590 } 591 592 uint32_t 593 PlatformRemoteAppleTV::FindFileInAllSDKs (const char *platform_file_path, 594 FileSpecList &file_list) 595 { 596 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST | LIBLLDB_LOG_VERBOSE); 597 if (platform_file_path && platform_file_path[0] && UpdateSDKDirectoryInfosIfNeeded()) 598 { 599 const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); 600 lldb_private::FileSpec local_file; 601 // First try for an exact match of major, minor and update 602 for (uint32_t sdk_idx=0; sdk_idx<num_sdk_infos; ++sdk_idx) 603 { 604 if (log) 605 { 606 log->Printf ("Searching for %s in sdk path %s", platform_file_path, m_sdk_directory_infos[sdk_idx].directory.GetPath().c_str()); 607 } 608 if (GetFileInSDK (platform_file_path, 609 sdk_idx, 610 local_file)) 611 { 612 file_list.Append(local_file); 613 } 614 } 615 } 616 return file_list.GetSize(); 617 } 618 619 bool 620 PlatformRemoteAppleTV::GetFileInSDK (const char *platform_file_path, 621 uint32_t sdk_idx, 622 lldb_private::FileSpec &local_file) 623 { 624 if (sdk_idx < m_sdk_directory_infos.size()) 625 { 626 char sdkroot_path[PATH_MAX]; 627 const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[sdk_idx]; 628 if (sdk_dir_info.directory.GetPath(sdkroot_path, sizeof(sdkroot_path))) 629 { 630 const bool symbols_dirs_only = true; 631 632 return GetFileInSDKRoot (platform_file_path, 633 sdkroot_path, 634 symbols_dirs_only, 635 local_file); 636 } 637 } 638 return false; 639 } 640 641 bool 642 PlatformRemoteAppleTV::GetFileInSDKRoot (const char *platform_file_path, 643 const char *sdkroot_path, 644 bool symbols_dirs_only, 645 lldb_private::FileSpec &local_file) 646 { 647 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST); 648 if (sdkroot_path && sdkroot_path[0] && platform_file_path && platform_file_path[0]) 649 { 650 char resolved_path[PATH_MAX]; 651 652 if (!symbols_dirs_only) 653 { 654 ::snprintf (resolved_path, 655 sizeof(resolved_path), 656 "%s%s", 657 sdkroot_path, 658 platform_file_path); 659 660 local_file.SetFile(resolved_path, true); 661 if (local_file.Exists()) 662 { 663 if (log) 664 { 665 log->Printf ("Found a copy of %s in the SDK dir %s", platform_file_path, sdkroot_path); 666 } 667 return true; 668 } 669 } 670 671 ::snprintf (resolved_path, 672 sizeof(resolved_path), 673 "%s/Symbols.Internal%s", 674 sdkroot_path, 675 platform_file_path); 676 677 local_file.SetFile(resolved_path, true); 678 if (local_file.Exists()) 679 { 680 if (log) 681 { 682 log->Printf ("Found a copy of %s in the SDK dir %s/Symbols.Internal", platform_file_path, sdkroot_path); 683 } 684 return true; 685 } 686 ::snprintf (resolved_path, 687 sizeof(resolved_path), 688 "%s/Symbols%s", 689 sdkroot_path, 690 platform_file_path); 691 692 local_file.SetFile(resolved_path, true); 693 if (local_file.Exists()) 694 { 695 if (log) 696 { 697 log->Printf ("Found a copy of %s in the SDK dir %s/Symbols", platform_file_path, sdkroot_path); 698 } 699 return true; 700 } 701 } 702 return false; 703 } 704 705 Error 706 PlatformRemoteAppleTV::GetSymbolFile (const FileSpec &platform_file, 707 const UUID *uuid_ptr, 708 FileSpec &local_file) 709 { 710 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST); 711 Error error; 712 char platform_file_path[PATH_MAX]; 713 if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) 714 { 715 char resolved_path[PATH_MAX]; 716 717 const char * os_version_dir = GetDeviceSupportDirectoryForOSVersion(); 718 if (os_version_dir) 719 { 720 ::snprintf (resolved_path, 721 sizeof(resolved_path), 722 "%s/%s", 723 os_version_dir, 724 platform_file_path); 725 726 local_file.SetFile(resolved_path, true); 727 if (local_file.Exists()) 728 { 729 if (log) 730 { 731 log->Printf ("Found a copy of %s in the DeviceSupport dir %s", platform_file_path, os_version_dir); 732 } 733 return error; 734 } 735 736 ::snprintf (resolved_path, 737 sizeof(resolved_path), 738 "%s/Symbols.Internal/%s", 739 os_version_dir, 740 platform_file_path); 741 742 local_file.SetFile(resolved_path, true); 743 if (local_file.Exists()) 744 { 745 if (log) 746 { 747 log->Printf ("Found a copy of %s in the DeviceSupport dir %s/Symbols.Internal", platform_file_path, os_version_dir); 748 } 749 return error; 750 } 751 ::snprintf (resolved_path, 752 sizeof(resolved_path), 753 "%s/Symbols/%s", 754 os_version_dir, 755 platform_file_path); 756 757 local_file.SetFile(resolved_path, true); 758 if (local_file.Exists()) 759 { 760 if (log) 761 { 762 log->Printf ("Found a copy of %s in the DeviceSupport dir %s/Symbols", platform_file_path, os_version_dir); 763 } 764 return error; 765 } 766 } 767 local_file = platform_file; 768 if (local_file.Exists()) 769 return error; 770 771 error.SetErrorStringWithFormat ("unable to locate a platform file for '%s' in platform '%s'", 772 platform_file_path, 773 GetPluginName().GetCString()); 774 } 775 else 776 { 777 error.SetErrorString ("invalid platform file argument"); 778 } 779 return error; 780 } 781 782 Error 783 PlatformRemoteAppleTV::GetSharedModule (const ModuleSpec &module_spec, 784 lldb_private::Process* process, 785 ModuleSP &module_sp, 786 const FileSpecList *module_search_paths_ptr, 787 ModuleSP *old_module_sp_ptr, 788 bool *did_create_ptr) 789 { 790 // For Apple TV, the SDK files are all cached locally on the host 791 // system. So first we ask for the file in the cached SDK, 792 // then we attempt to get a shared module for the right architecture 793 // with the right UUID. 794 const FileSpec &platform_file = module_spec.GetFileSpec(); 795 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST | LIBLLDB_LOG_VERBOSE); 796 797 Error error; 798 char platform_file_path[PATH_MAX]; 799 800 if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) 801 { 802 ModuleSpec platform_module_spec(module_spec); 803 804 UpdateSDKDirectoryInfosIfNeeded(); 805 806 const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); 807 808 // If we are connected we migth be able to correctly deduce the SDK directory 809 // using the OS build. 810 const uint32_t connected_sdk_idx = GetConnectedSDKIndex (); 811 if (connected_sdk_idx < num_sdk_infos) 812 { 813 if (log) 814 { 815 log->Printf ("Searching for %s in sdk path %s", platform_file_path, m_sdk_directory_infos[connected_sdk_idx].directory.GetPath().c_str()); 816 } 817 if (GetFileInSDK (platform_file_path, connected_sdk_idx, platform_module_spec.GetFileSpec())) 818 { 819 module_sp.reset(); 820 error = ResolveExecutable(platform_module_spec, 821 module_sp, 822 nullptr); 823 if (module_sp) 824 { 825 m_last_module_sdk_idx = connected_sdk_idx; 826 error.Clear(); 827 return error; 828 } 829 } 830 } 831 832 // Try the last SDK index if it is set as most files from an SDK 833 // will tend to be valid in that same SDK. 834 if (m_last_module_sdk_idx < num_sdk_infos) 835 { 836 if (log) 837 { 838 log->Printf ("Searching for %s in sdk path %s", platform_file_path, m_sdk_directory_infos[m_last_module_sdk_idx].directory.GetPath().c_str()); 839 } 840 if (GetFileInSDK (platform_file_path, m_last_module_sdk_idx, platform_module_spec.GetFileSpec())) 841 { 842 module_sp.reset(); 843 error = ResolveExecutable(platform_module_spec, 844 module_sp, 845 nullptr); 846 if (module_sp) 847 { 848 error.Clear(); 849 return error; 850 } 851 } 852 } 853 854 // First try for an exact match of major, minor and update 855 for (uint32_t sdk_idx=0; sdk_idx<num_sdk_infos; ++sdk_idx) 856 { 857 if (m_last_module_sdk_idx == sdk_idx) 858 { 859 // Skip the last module SDK index if we already searched 860 // it above 861 continue; 862 } 863 if (log) 864 { 865 log->Printf ("Searching for %s in sdk path %s", platform_file_path, m_sdk_directory_infos[sdk_idx].directory.GetPath().c_str()); 866 } 867 if (GetFileInSDK (platform_file_path, sdk_idx, platform_module_spec.GetFileSpec())) 868 { 869 //printf ("sdk[%u]: '%s'\n", sdk_idx, local_file.GetPath().c_str()); 870 871 error = ResolveExecutable(platform_module_spec, module_sp, nullptr); 872 if (module_sp) 873 { 874 // Remember the index of the last SDK that we found a file 875 // in in case the wrong SDK was selected. 876 m_last_module_sdk_idx = sdk_idx; 877 error.Clear(); 878 return error; 879 } 880 } 881 } 882 } 883 // Not the module we are looking for... Nothing to see here... 884 module_sp.reset(); 885 886 // This may not be an SDK-related module. Try whether we can bring in the thing to our local cache. 887 error = GetSharedModuleWithLocalCache(module_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr, did_create_ptr); 888 if (error.Success()) 889 return error; 890 891 const bool always_create = false; 892 error = ModuleList::GetSharedModule (module_spec, 893 module_sp, 894 module_search_paths_ptr, 895 old_module_sp_ptr, 896 did_create_ptr, 897 always_create); 898 899 if (module_sp) 900 module_sp->SetPlatformFileSpec(platform_file); 901 902 return error; 903 } 904 905 bool 906 PlatformRemoteAppleTV::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch) 907 { 908 ArchSpec system_arch (GetSystemArchitecture()); 909 910 const ArchSpec::Core system_core = system_arch.GetCore(); 911 switch (system_core) 912 { 913 default: 914 switch (idx) 915 { 916 case 0: arch.SetTriple ("arm64-apple-tvos"); return true; 917 case 1: arch.SetTriple ("armv7s-apple-tvos"); return true; 918 case 2: arch.SetTriple ("armv7-apple-tvos"); return true; 919 case 3: arch.SetTriple ("thumbv7s-apple-tvos"); return true; 920 case 4: arch.SetTriple ("thumbv7-apple-tvos"); return true; 921 default: break; 922 } 923 break; 924 925 case ArchSpec::eCore_arm_arm64: 926 switch (idx) 927 { 928 case 0: arch.SetTriple ("arm64-apple-tvos"); return true; 929 case 1: arch.SetTriple ("armv7s-apple-tvos"); return true; 930 case 2: arch.SetTriple ("armv7-apple-tvos"); return true; 931 case 3: arch.SetTriple ("thumbv7s-apple-tvos"); return true; 932 case 4: arch.SetTriple ("thumbv7-apple-tvos"); return true; 933 default: break; 934 } 935 break; 936 937 case ArchSpec::eCore_arm_armv7s: 938 switch (idx) 939 { 940 case 0: arch.SetTriple ("armv7s-apple-tvos"); return true; 941 case 1: arch.SetTriple ("armv7-apple-tvos"); return true; 942 case 2: arch.SetTriple ("thumbv7s-apple-tvos"); return true; 943 case 3: arch.SetTriple ("thumbv7-apple-tvos"); return true; 944 default: break; 945 } 946 break; 947 948 case ArchSpec::eCore_arm_armv7: 949 switch (idx) 950 { 951 case 0: arch.SetTriple ("armv7-apple-tvos"); return true; 952 case 1: arch.SetTriple ("thumbv7-apple-tvos"); return true; 953 default: break; 954 } 955 break; 956 } 957 arch.Clear(); 958 return false; 959 } 960 961 uint32_t 962 PlatformRemoteAppleTV::GetConnectedSDKIndex () 963 { 964 if (IsConnected()) 965 { 966 if (m_connected_module_sdk_idx == UINT32_MAX) 967 { 968 std::string build; 969 if (GetRemoteOSBuildString(build)) 970 { 971 const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); 972 for (uint32_t i=0; i<num_sdk_infos; ++i) 973 { 974 const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[i]; 975 if (strstr(sdk_dir_info.directory.GetFilename().AsCString(""), build.c_str())) 976 { 977 m_connected_module_sdk_idx = i; 978 } 979 } 980 } 981 } 982 } 983 else 984 { 985 m_connected_module_sdk_idx = UINT32_MAX; 986 } 987 return m_connected_module_sdk_idx; 988 } 989