1 //===-- TargetList.cpp ------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/Target/TargetList.h" 11 #include "lldb/Core/Debugger.h" 12 #include "lldb/Core/Module.h" 13 #include "lldb/Core/ModuleSpec.h" 14 #include "lldb/Host/Host.h" 15 #include "lldb/Host/HostInfo.h" 16 #include "lldb/Interpreter/CommandInterpreter.h" 17 #include "lldb/Interpreter/OptionGroupPlatform.h" 18 #include "lldb/Symbol/ObjectFile.h" 19 #include "lldb/Target/Platform.h" 20 #include "lldb/Target/Process.h" 21 #include "lldb/Utility/Broadcaster.h" 22 #include "lldb/Utility/Event.h" 23 #include "lldb/Utility/State.h" 24 #include "lldb/Utility/TildeExpressionResolver.h" 25 #include "lldb/Utility/Timer.h" 26 27 #include "llvm/ADT/SmallString.h" 28 #include "llvm/Support/FileSystem.h" 29 30 using namespace lldb; 31 using namespace lldb_private; 32 33 ConstString &TargetList::GetStaticBroadcasterClass() { 34 static ConstString class_name("lldb.targetList"); 35 return class_name; 36 } 37 38 //---------------------------------------------------------------------- 39 // TargetList constructor 40 //---------------------------------------------------------------------- 41 TargetList::TargetList(Debugger &debugger) 42 : Broadcaster(debugger.GetBroadcasterManager(), 43 TargetList::GetStaticBroadcasterClass().AsCString()), 44 m_target_list(), m_target_list_mutex(), m_selected_target_idx(0) { 45 CheckInWithManager(); 46 } 47 48 //---------------------------------------------------------------------- 49 // Destructor 50 //---------------------------------------------------------------------- 51 TargetList::~TargetList() { 52 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 53 m_target_list.clear(); 54 } 55 56 Status TargetList::CreateTarget(Debugger &debugger, 57 llvm::StringRef user_exe_path, 58 llvm::StringRef triple_str, 59 LoadDependentFiles load_dependent_files, 60 const OptionGroupPlatform *platform_options, 61 TargetSP &target_sp) { 62 return CreateTargetInternal(debugger, user_exe_path, triple_str, 63 load_dependent_files, platform_options, target_sp, 64 false); 65 } 66 67 Status TargetList::CreateTarget(Debugger &debugger, 68 llvm::StringRef user_exe_path, 69 const ArchSpec &specified_arch, 70 LoadDependentFiles load_dependent_files, 71 PlatformSP &platform_sp, TargetSP &target_sp) { 72 return CreateTargetInternal(debugger, user_exe_path, specified_arch, 73 load_dependent_files, platform_sp, target_sp, 74 false); 75 } 76 77 Status TargetList::CreateTargetInternal( 78 Debugger &debugger, llvm::StringRef user_exe_path, 79 llvm::StringRef triple_str, LoadDependentFiles load_dependent_files, 80 const OptionGroupPlatform *platform_options, TargetSP &target_sp, 81 bool is_dummy_target) { 82 Status error; 83 PlatformSP platform_sp; 84 85 // This is purposely left empty unless it is specified by triple_cstr. If not 86 // initialized via triple_cstr, then the currently selected platform will set 87 // the architecture correctly. 88 const ArchSpec arch(triple_str); 89 if (!triple_str.empty()) { 90 if (!arch.IsValid()) { 91 error.SetErrorStringWithFormat("invalid triple '%s'", 92 triple_str.str().c_str()); 93 return error; 94 } 95 } 96 97 ArchSpec platform_arch(arch); 98 99 bool prefer_platform_arch = false; 100 101 CommandInterpreter &interpreter = debugger.GetCommandInterpreter(); 102 103 // let's see if there is already an existing platform before we go creating 104 // another... 105 platform_sp = debugger.GetPlatformList().GetSelectedPlatform(); 106 107 if (platform_options && platform_options->PlatformWasSpecified()) { 108 // Create a new platform if it doesn't match the selected platform 109 if (!platform_options->PlatformMatches(platform_sp)) { 110 const bool select_platform = true; 111 platform_sp = platform_options->CreatePlatformWithOptions( 112 interpreter, arch, select_platform, error, platform_arch); 113 if (!platform_sp) 114 return error; 115 } 116 } 117 118 if (!user_exe_path.empty()) { 119 ModuleSpecList module_specs; 120 ModuleSpec module_spec; 121 module_spec.GetFileSpec().SetFile(user_exe_path, FileSpec::Style::native); 122 FileSystem::Instance().Resolve(module_spec.GetFileSpec()); 123 124 // Resolve the executable in case we are given a path to a application 125 // bundle like a .app bundle on MacOSX 126 Host::ResolveExecutableInBundle(module_spec.GetFileSpec()); 127 128 lldb::offset_t file_offset = 0; 129 lldb::offset_t file_size = 0; 130 const size_t num_specs = ObjectFile::GetModuleSpecifications( 131 module_spec.GetFileSpec(), file_offset, file_size, module_specs); 132 if (num_specs > 0) { 133 ModuleSpec matching_module_spec; 134 135 if (num_specs == 1) { 136 if (module_specs.GetModuleSpecAtIndex(0, matching_module_spec)) { 137 if (platform_arch.IsValid()) { 138 if (platform_arch.IsCompatibleMatch( 139 matching_module_spec.GetArchitecture())) { 140 // If the OS or vendor weren't specified, then adopt the module's 141 // architecture so that the platform matching can be more 142 // accurate 143 if (!platform_arch.TripleOSWasSpecified() || 144 !platform_arch.TripleVendorWasSpecified()) { 145 prefer_platform_arch = true; 146 platform_arch = matching_module_spec.GetArchitecture(); 147 } 148 } else { 149 StreamString platform_arch_strm; 150 StreamString module_arch_strm; 151 152 platform_arch.DumpTriple(platform_arch_strm); 153 matching_module_spec.GetArchitecture().DumpTriple( 154 module_arch_strm); 155 error.SetErrorStringWithFormat( 156 "the specified architecture '%s' is not compatible with '%s' " 157 "in '%s'", 158 platform_arch_strm.GetData(), module_arch_strm.GetData(), 159 module_spec.GetFileSpec().GetPath().c_str()); 160 return error; 161 } 162 } else { 163 // Only one arch and none was specified 164 prefer_platform_arch = true; 165 platform_arch = matching_module_spec.GetArchitecture(); 166 } 167 } 168 } else { 169 if (arch.IsValid()) { 170 module_spec.GetArchitecture() = arch; 171 if (module_specs.FindMatchingModuleSpec(module_spec, 172 matching_module_spec)) { 173 prefer_platform_arch = true; 174 platform_arch = matching_module_spec.GetArchitecture(); 175 } 176 } else { 177 // No architecture specified, check if there is only one platform for 178 // all of the architectures. 179 180 typedef std::vector<PlatformSP> PlatformList; 181 PlatformList platforms; 182 PlatformSP host_platform_sp = Platform::GetHostPlatform(); 183 for (size_t i = 0; i < num_specs; ++i) { 184 ModuleSpec module_spec; 185 if (module_specs.GetModuleSpecAtIndex(i, module_spec)) { 186 // See if there was a selected platform and check that first 187 // since the user may have specified it. 188 if (platform_sp) { 189 if (platform_sp->IsCompatibleArchitecture( 190 module_spec.GetArchitecture(), false, nullptr)) { 191 platforms.push_back(platform_sp); 192 continue; 193 } 194 } 195 196 // Next check the host platform it if wasn't already checked 197 // above 198 if (host_platform_sp && 199 (!platform_sp || 200 host_platform_sp->GetName() != platform_sp->GetName())) { 201 if (host_platform_sp->IsCompatibleArchitecture( 202 module_spec.GetArchitecture(), false, nullptr)) { 203 platforms.push_back(host_platform_sp); 204 continue; 205 } 206 } 207 208 // Just find a platform that matches the architecture in the 209 // executable file 210 PlatformSP fallback_platform_sp( 211 Platform::GetPlatformForArchitecture( 212 module_spec.GetArchitecture(), nullptr)); 213 if (fallback_platform_sp) { 214 platforms.push_back(fallback_platform_sp); 215 } 216 } 217 } 218 219 Platform *platform_ptr = nullptr; 220 bool more_than_one_platforms = false; 221 for (const auto &the_platform_sp : platforms) { 222 if (platform_ptr) { 223 if (platform_ptr->GetName() != the_platform_sp->GetName()) { 224 more_than_one_platforms = true; 225 platform_ptr = nullptr; 226 break; 227 } 228 } else { 229 platform_ptr = the_platform_sp.get(); 230 } 231 } 232 233 if (platform_ptr) { 234 // All platforms for all modules in the executable match, so we can 235 // select this platform 236 platform_sp = platforms.front(); 237 } else if (!more_than_one_platforms) { 238 // No platforms claim to support this file 239 error.SetErrorString("No matching platforms found for this file, " 240 "specify one with the --platform option"); 241 return error; 242 } else { 243 // More than one platform claims to support this file, so the 244 // --platform option must be specified 245 StreamString error_strm; 246 std::set<Platform *> platform_set; 247 error_strm.Printf( 248 "more than one platform supports this executable ("); 249 for (const auto &the_platform_sp : platforms) { 250 if (platform_set.find(the_platform_sp.get()) == 251 platform_set.end()) { 252 if (!platform_set.empty()) 253 error_strm.PutCString(", "); 254 error_strm.PutCString(the_platform_sp->GetName().GetCString()); 255 platform_set.insert(the_platform_sp.get()); 256 } 257 } 258 error_strm.Printf( 259 "), use the --platform option to specify a platform"); 260 error.SetErrorString(error_strm.GetString()); 261 return error; 262 } 263 } 264 } 265 } 266 } 267 268 // If we have a valid architecture, make sure the current platform is 269 // compatible with that architecture 270 if (!prefer_platform_arch && arch.IsValid()) { 271 if (!platform_sp->IsCompatibleArchitecture(arch, false, &platform_arch)) { 272 platform_sp = Platform::GetPlatformForArchitecture(arch, &platform_arch); 273 if (!is_dummy_target && platform_sp) 274 debugger.GetPlatformList().SetSelectedPlatform(platform_sp); 275 } 276 } else if (platform_arch.IsValid()) { 277 // if "arch" isn't valid, yet "platform_arch" is, it means we have an 278 // executable file with a single architecture which should be used 279 ArchSpec fixed_platform_arch; 280 if (!platform_sp->IsCompatibleArchitecture(platform_arch, false, 281 &fixed_platform_arch)) { 282 platform_sp = Platform::GetPlatformForArchitecture(platform_arch, 283 &fixed_platform_arch); 284 if (!is_dummy_target && platform_sp) 285 debugger.GetPlatformList().SetSelectedPlatform(platform_sp); 286 } 287 } 288 289 if (!platform_arch.IsValid()) 290 platform_arch = arch; 291 292 error = TargetList::CreateTargetInternal( 293 debugger, user_exe_path, platform_arch, load_dependent_files, platform_sp, 294 target_sp, is_dummy_target); 295 return error; 296 } 297 298 lldb::TargetSP TargetList::GetDummyTarget(lldb_private::Debugger &debugger) { 299 // FIXME: Maybe the dummy target should be per-Debugger 300 if (!m_dummy_target_sp || !m_dummy_target_sp->IsValid()) { 301 ArchSpec arch(Target::GetDefaultArchitecture()); 302 if (!arch.IsValid()) 303 arch = HostInfo::GetArchitecture(); 304 Status err = CreateDummyTarget( 305 debugger, arch.GetTriple().getTriple().c_str(), m_dummy_target_sp); 306 } 307 308 return m_dummy_target_sp; 309 } 310 311 Status TargetList::CreateDummyTarget(Debugger &debugger, 312 llvm::StringRef specified_arch_name, 313 lldb::TargetSP &target_sp) { 314 PlatformSP host_platform_sp(Platform::GetHostPlatform()); 315 return CreateTargetInternal( 316 debugger, (const char *)nullptr, specified_arch_name, eLoadDependentsNo, 317 (const OptionGroupPlatform *)nullptr, target_sp, true); 318 } 319 320 Status TargetList::CreateTargetInternal(Debugger &debugger, 321 llvm::StringRef user_exe_path, 322 const ArchSpec &specified_arch, 323 LoadDependentFiles load_dependent_files, 324 lldb::PlatformSP &platform_sp, 325 lldb::TargetSP &target_sp, 326 bool is_dummy_target) { 327 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); 328 Timer scoped_timer( 329 func_cat, "TargetList::CreateTarget (file = '%s', arch = '%s')", 330 user_exe_path.str().c_str(), specified_arch.GetArchitectureName()); 331 Status error; 332 333 ArchSpec arch(specified_arch); 334 335 if (arch.IsValid()) { 336 if (!platform_sp || 337 !platform_sp->IsCompatibleArchitecture(arch, false, nullptr)) 338 platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch); 339 } 340 341 if (!platform_sp) 342 platform_sp = debugger.GetPlatformList().GetSelectedPlatform(); 343 344 if (!arch.IsValid()) 345 arch = specified_arch; 346 347 FileSpec file(user_exe_path); 348 if (!FileSystem::Instance().Exists(file) && user_exe_path.startswith("~")) { 349 // we want to expand the tilde but we don't want to resolve any symbolic 350 // links so we can't use the FileSpec constructor's resolve flag 351 llvm::SmallString<64> unglobbed_path; 352 StandardTildeExpressionResolver Resolver; 353 Resolver.ResolveFullPath(user_exe_path, unglobbed_path); 354 355 if (unglobbed_path.empty()) 356 file = FileSpec(user_exe_path); 357 else 358 file = FileSpec(unglobbed_path.c_str()); 359 } 360 361 bool user_exe_path_is_bundle = false; 362 char resolved_bundle_exe_path[PATH_MAX]; 363 resolved_bundle_exe_path[0] = '\0'; 364 if (file) { 365 if (FileSystem::Instance().IsDirectory(file)) 366 user_exe_path_is_bundle = true; 367 368 if (file.IsRelative() && !user_exe_path.empty()) { 369 llvm::SmallString<64> cwd; 370 if (! llvm::sys::fs::current_path(cwd)) { 371 FileSpec cwd_file(cwd.c_str()); 372 cwd_file.AppendPathComponent(file); 373 if (FileSystem::Instance().Exists(cwd_file)) 374 file = cwd_file; 375 } 376 } 377 378 ModuleSP exe_module_sp; 379 if (platform_sp) { 380 FileSpecList executable_search_paths( 381 Target::GetDefaultExecutableSearchPaths()); 382 ModuleSpec module_spec(file, arch); 383 error = platform_sp->ResolveExecutable(module_spec, exe_module_sp, 384 executable_search_paths.GetSize() 385 ? &executable_search_paths 386 : nullptr); 387 } 388 389 if (error.Success() && exe_module_sp) { 390 if (exe_module_sp->GetObjectFile() == nullptr) { 391 if (arch.IsValid()) { 392 error.SetErrorStringWithFormat( 393 "\"%s\" doesn't contain architecture %s", file.GetPath().c_str(), 394 arch.GetArchitectureName()); 395 } else { 396 error.SetErrorStringWithFormat("unsupported file type \"%s\"", 397 file.GetPath().c_str()); 398 } 399 return error; 400 } 401 target_sp.reset(new Target(debugger, arch, platform_sp, is_dummy_target)); 402 target_sp->SetExecutableModule(exe_module_sp, load_dependent_files); 403 if (user_exe_path_is_bundle) 404 exe_module_sp->GetFileSpec().GetPath(resolved_bundle_exe_path, 405 sizeof(resolved_bundle_exe_path)); 406 } 407 } else { 408 // No file was specified, just create an empty target with any arch if a 409 // valid arch was specified 410 target_sp.reset(new Target(debugger, arch, platform_sp, is_dummy_target)); 411 } 412 413 if (target_sp) { 414 // Set argv0 with what the user typed, unless the user specified a 415 // directory. If the user specified a directory, then it is probably a 416 // bundle that was resolved and we need to use the resolved bundle path 417 if (!user_exe_path.empty()) { 418 // Use exactly what the user typed as the first argument when we exec or 419 // posix_spawn 420 if (user_exe_path_is_bundle && resolved_bundle_exe_path[0]) { 421 target_sp->SetArg0(resolved_bundle_exe_path); 422 } else { 423 // Use resolved path 424 target_sp->SetArg0(file.GetPath().c_str()); 425 } 426 } 427 if (file.GetDirectory()) { 428 FileSpec file_dir; 429 file_dir.GetDirectory() = file.GetDirectory(); 430 target_sp->GetExecutableSearchPaths().Append(file_dir); 431 } 432 433 // Don't put the dummy target in the target list, it's held separately. 434 if (!is_dummy_target) { 435 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 436 m_selected_target_idx = m_target_list.size(); 437 m_target_list.push_back(target_sp); 438 // Now prime this from the dummy target: 439 target_sp->PrimeFromDummyTarget(debugger.GetDummyTarget()); 440 } else { 441 m_dummy_target_sp = target_sp; 442 } 443 } 444 445 return error; 446 } 447 448 bool TargetList::DeleteTarget(TargetSP &target_sp) { 449 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 450 collection::iterator pos, end = m_target_list.end(); 451 452 for (pos = m_target_list.begin(); pos != end; ++pos) { 453 if (pos->get() == target_sp.get()) { 454 m_target_list.erase(pos); 455 return true; 456 } 457 } 458 return false; 459 } 460 461 TargetSP TargetList::FindTargetWithExecutableAndArchitecture( 462 const FileSpec &exe_file_spec, const ArchSpec *exe_arch_ptr) const { 463 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 464 TargetSP target_sp; 465 bool full_match = (bool)exe_file_spec.GetDirectory(); 466 467 collection::const_iterator pos, end = m_target_list.end(); 468 for (pos = m_target_list.begin(); pos != end; ++pos) { 469 Module *exe_module = (*pos)->GetExecutableModulePointer(); 470 471 if (exe_module) { 472 if (FileSpec::Equal(exe_file_spec, exe_module->GetFileSpec(), 473 full_match)) { 474 if (exe_arch_ptr) { 475 if (!exe_arch_ptr->IsCompatibleMatch(exe_module->GetArchitecture())) 476 continue; 477 } 478 target_sp = *pos; 479 break; 480 } 481 } 482 } 483 return target_sp; 484 } 485 486 TargetSP TargetList::FindTargetWithProcessID(lldb::pid_t pid) const { 487 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 488 TargetSP target_sp; 489 collection::const_iterator pos, end = m_target_list.end(); 490 for (pos = m_target_list.begin(); pos != end; ++pos) { 491 Process *process = (*pos)->GetProcessSP().get(); 492 if (process && process->GetID() == pid) { 493 target_sp = *pos; 494 break; 495 } 496 } 497 return target_sp; 498 } 499 500 TargetSP TargetList::FindTargetWithProcess(Process *process) const { 501 TargetSP target_sp; 502 if (process) { 503 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 504 collection::const_iterator pos, end = m_target_list.end(); 505 for (pos = m_target_list.begin(); pos != end; ++pos) { 506 if (process == (*pos)->GetProcessSP().get()) { 507 target_sp = *pos; 508 break; 509 } 510 } 511 } 512 return target_sp; 513 } 514 515 TargetSP TargetList::GetTargetSP(Target *target) const { 516 TargetSP target_sp; 517 if (target) { 518 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 519 collection::const_iterator pos, end = m_target_list.end(); 520 for (pos = m_target_list.begin(); pos != end; ++pos) { 521 if (target == (*pos).get()) { 522 target_sp = *pos; 523 break; 524 } 525 } 526 } 527 return target_sp; 528 } 529 530 uint32_t TargetList::SendAsyncInterrupt(lldb::pid_t pid) { 531 uint32_t num_async_interrupts_sent = 0; 532 533 if (pid != LLDB_INVALID_PROCESS_ID) { 534 TargetSP target_sp(FindTargetWithProcessID(pid)); 535 if (target_sp) { 536 Process *process = target_sp->GetProcessSP().get(); 537 if (process) { 538 process->SendAsyncInterrupt(); 539 ++num_async_interrupts_sent; 540 } 541 } 542 } else { 543 // We don't have a valid pid to broadcast to, so broadcast to the target 544 // list's async broadcaster... 545 BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr); 546 } 547 548 return num_async_interrupts_sent; 549 } 550 551 uint32_t TargetList::SignalIfRunning(lldb::pid_t pid, int signo) { 552 uint32_t num_signals_sent = 0; 553 Process *process = nullptr; 554 if (pid == LLDB_INVALID_PROCESS_ID) { 555 // Signal all processes with signal 556 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 557 collection::iterator pos, end = m_target_list.end(); 558 for (pos = m_target_list.begin(); pos != end; ++pos) { 559 process = (*pos)->GetProcessSP().get(); 560 if (process) { 561 if (process->IsAlive()) { 562 ++num_signals_sent; 563 process->Signal(signo); 564 } 565 } 566 } 567 } else { 568 // Signal a specific process with signal 569 TargetSP target_sp(FindTargetWithProcessID(pid)); 570 if (target_sp) { 571 process = target_sp->GetProcessSP().get(); 572 if (process) { 573 if (process->IsAlive()) { 574 ++num_signals_sent; 575 process->Signal(signo); 576 } 577 } 578 } 579 } 580 return num_signals_sent; 581 } 582 583 int TargetList::GetNumTargets() const { 584 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 585 return m_target_list.size(); 586 } 587 588 lldb::TargetSP TargetList::GetTargetAtIndex(uint32_t idx) const { 589 TargetSP target_sp; 590 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 591 if (idx < m_target_list.size()) 592 target_sp = m_target_list[idx]; 593 return target_sp; 594 } 595 596 uint32_t TargetList::GetIndexOfTarget(lldb::TargetSP target_sp) const { 597 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 598 size_t num_targets = m_target_list.size(); 599 for (size_t idx = 0; idx < num_targets; idx++) { 600 if (target_sp == m_target_list[idx]) 601 return idx; 602 } 603 return UINT32_MAX; 604 } 605 606 uint32_t TargetList::SetSelectedTarget(Target *target) { 607 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 608 collection::const_iterator pos, begin = m_target_list.begin(), 609 end = m_target_list.end(); 610 for (pos = begin; pos != end; ++pos) { 611 if (pos->get() == target) { 612 m_selected_target_idx = std::distance(begin, pos); 613 return m_selected_target_idx; 614 } 615 } 616 m_selected_target_idx = 0; 617 return m_selected_target_idx; 618 } 619 620 lldb::TargetSP TargetList::GetSelectedTarget() { 621 std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex); 622 if (m_selected_target_idx >= m_target_list.size()) 623 m_selected_target_idx = 0; 624 return GetTargetAtIndex(m_selected_target_idx); 625 } 626