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