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