contrib/llvm/tools/lldb/source/Target/TargetList.cpp

   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/lldb-python.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Core/Broadcaster.h"
  17 #include "lldb/Core/Debugger.h"
  18 #include "lldb/Core/Event.h"
  19 #include "lldb/Core/Module.h"
  20 #include "lldb/Core/ModuleSpec.h"
  21 #include "lldb/Core/State.h"
  22 #include "lldb/Core/Timer.h"
  23 #include "lldb/Host/Host.h"
  24 #include "lldb/Interpreter/CommandInterpreter.h"
  25 #include "lldb/Interpreter/OptionGroupPlatform.h"
  26 #include "lldb/Symbol/ObjectFile.h"
  27 #include "lldb/Target/Platform.h"
  28 #include "lldb/Target/Process.h"
  29 #include "lldb/Target/TargetList.h"
  30
  31 using namespace lldb;
  32 using namespace lldb_private;
  33
  34 ConstString &
  35 TargetList::GetStaticBroadcasterClass ()
  36 {
  37     static ConstString class_name ("lldb.targetList");
  38     return class_name;
  39 }
  40
  41 //----------------------------------------------------------------------
  42 // TargetList constructor
  43 //----------------------------------------------------------------------
  44 TargetList::TargetList(Debugger &debugger) :
  45     Broadcaster(&debugger, TargetList::GetStaticBroadcasterClass().AsCString()),
  46     m_target_list(),
  47     m_target_list_mutex (Mutex::eMutexTypeRecursive),
  48     m_selected_target_idx (0)
  49 {
  50     CheckInWithManager();
  51 }
  52
  53 //----------------------------------------------------------------------
  54 // Destructor
  55 //----------------------------------------------------------------------
  56 TargetList::~TargetList()
  57 {
  58     Mutex::Locker locker(m_target_list_mutex);
  59     m_target_list.clear();
  60 }
  61
  62 Error
  63 TargetList::CreateTarget (Debugger &debugger,
  64                           const char *user_exe_path,
  65                           const char *triple_cstr,
  66                           bool get_dependent_files,
  67                           const OptionGroupPlatform *platform_options,
  68                           TargetSP &target_sp)
  69 {
  70     Error error;
  71     PlatformSP platform_sp;
  72
  73     // This is purposely left empty unless it is specified by triple_cstr.
  74     // If not initialized via triple_cstr, then the currently selected platform
  75     // will set the architecture correctly.
  76     const ArchSpec arch(triple_cstr);
  77     if (triple_cstr && triple_cstr[0])
  78     {
  79         if (!arch.IsValid())
  80         {
  81             error.SetErrorStringWithFormat("invalid triple '%s'", triple_cstr);
  82             return error;
  83         }
  84     }
  85
  86     ArchSpec platform_arch(arch);
  87
  88
  89     if (user_exe_path && user_exe_path[0])
  90     {
  91         ModuleSpecList module_specs;
  92         ModuleSpec module_spec;
  93         module_spec.GetFileSpec().SetFile(user_exe_path, true);
  94         lldb::offset_t file_offset = 0;
  95         lldb::offset_t file_size = 0;
  96         const size_t num_specs = ObjectFile::GetModuleSpecifications (module_spec.GetFileSpec(), file_offset, file_size, module_specs);
  97         if (num_specs > 0)
  98         {
  99             ModuleSpec matching_module_spec;
 100
 101             if (num_specs == 1)
 102             {
 103                 if (module_specs.GetModuleSpecAtIndex(0, matching_module_spec))
 104                 {
 105                     if (platform_arch.IsValid())
 106                     {
 107                         if (!platform_arch.IsCompatibleMatch(matching_module_spec.GetArchitecture()))
 108                         {
 109                             error.SetErrorStringWithFormat("the specified architecture '%s' is not compatible with '%s' in '%s'",
 110                                                            platform_arch.GetTriple().str().c_str(),
 111                                                            matching_module_spec.GetArchitecture().GetTriple().str().c_str(),
 112                                                            module_spec.GetFileSpec().GetPath().c_str());
 113                             return error;
 114                         }
 115                     }
 116                     else
 117                     {
 118                         // Only one arch and none was specified
 119                         platform_arch = matching_module_spec.GetArchitecture();
 120                     }
 121                 }
 122             }
 123             else
 124             {
 125                 if (arch.IsValid())
 126                 {
 127                     module_spec.GetArchitecture() = arch;
 128                     if (module_specs.FindMatchingModuleSpec(module_spec, matching_module_spec))
 129                     {
 130                         platform_arch = matching_module_spec.GetArchitecture();
 131                     }
 132                 }
 133                 // Don't just select the first architecture, we want to let the platform select
 134                 // the best architecture first when there are multiple archs.
 135 //                else
 136 //                {
 137 //                    // No arch specified, select the first arch
 138 //                    if (module_specs.GetModuleSpecAtIndex(0, matching_module_spec))
 139 //                    {
 140 //                        platform_arch = matching_module_spec.GetArchitecture();
 141 //                    }
 142 //                }
 143             }
 144         }
 145     }
 146
 147     CommandInterpreter &interpreter = debugger.GetCommandInterpreter();
 148     if (platform_options)
 149     {
 150         if (platform_options->PlatformWasSpecified ())
 151         {
 152             const bool select_platform = true;
 153             platform_sp = platform_options->CreatePlatformWithOptions (interpreter,
 154                                                                        arch,
 155                                                                        select_platform,
 156                                                                        error,
 157                                                                        platform_arch);
 158             if (!platform_sp)
 159                 return error;
 160         }
 161     }
 162
 163     if (!platform_sp)
 164     {
 165         // Get the current platform and make sure it is compatible with the
 166         // current architecture if we have a valid architecture.
 167         platform_sp = debugger.GetPlatformList().GetSelectedPlatform ();
 168
 169         if (arch.IsValid() && !platform_sp->IsCompatibleArchitecture(arch, false, &platform_arch))
 170         {
 171             platform_sp = Platform::GetPlatformForArchitecture(arch, &platform_arch);
 172         }
 173     }
 174
 175     if (!platform_arch.IsValid())
 176         platform_arch = arch;
 177
 178     error = TargetList::CreateTarget (debugger,
 179                                       user_exe_path,
 180                                       platform_arch,
 181                                       get_dependent_files,
 182                                       platform_sp,
 183                                       target_sp);
 184     return error;
 185 }
 186
 187 Error
 188 TargetList::CreateTarget (Debugger &debugger,
 189                           const char *user_exe_path,
 190                           const ArchSpec& specified_arch,
 191                           bool get_dependent_files,
 192                           PlatformSP &platform_sp,
 193                           TargetSP &target_sp)
 194 {
 195     Timer scoped_timer (__PRETTY_FUNCTION__,
 196                         "TargetList::CreateTarget (file = '%s', arch = '%s')",
 197                         user_exe_path,
 198                         specified_arch.GetArchitectureName());
 199     Error error;
 200
 201     ArchSpec arch(specified_arch);
 202
 203     if (platform_sp)
 204     {
 205         if (arch.IsValid())
 206         {
 207             if (!platform_sp->IsCompatibleArchitecture(arch, false, NULL))
 208                 platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch);
 209         }
 210     }
 211     else if (arch.IsValid())
 212     {
 213         platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch);
 214     }
 215
 216     if (!platform_sp)
 217         platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
 218
 219     if (!arch.IsValid())
 220         arch = specified_arch;
 221
 222     FileSpec file (user_exe_path, false);
 223     if (!file.Exists() && user_exe_path && user_exe_path[0] == '~')
 224     {
 225         // we want to expand the tilde but we don't want to resolve any symbolic links
 226         // so we can't use the FileSpec constructor's resolve flag
 227         char unglobbed_path[PATH_MAX];
 228         unglobbed_path[0] = '\0';
 229
 230         size_t return_count = FileSpec::ResolveUsername(user_exe_path, unglobbed_path, sizeof(unglobbed_path));
 231
 232         if (return_count == 0 || return_count >= sizeof(unglobbed_path))
 233             ::snprintf (unglobbed_path, sizeof(unglobbed_path), "%s", user_exe_path);
 234
 235         file = FileSpec(unglobbed_path, false);
 236     }
 237
 238     bool user_exe_path_is_bundle = false;
 239     char resolved_bundle_exe_path[PATH_MAX];
 240     resolved_bundle_exe_path[0] = '\0';
 241     if (file)
 242     {
 243         if (file.GetFileType() == FileSpec::eFileTypeDirectory)
 244             user_exe_path_is_bundle = true;
 245
 246         if (file.IsRelativeToCurrentWorkingDirectory())
 247         {
 248             // Ignore paths that start with "./" and "../"
 249             if (!((user_exe_path[0] == '.' && user_exe_path[1] == '/') ||
 250                   (user_exe_path[0] == '.' && user_exe_path[1] == '.' && user_exe_path[2] == '/')))
 251             {
 252                 char cwd[PATH_MAX];
 253                 if (getcwd (cwd, sizeof(cwd)))
 254                 {
 255                     std::string cwd_user_exe_path (cwd);
 256                     cwd_user_exe_path += '/';
 257                     cwd_user_exe_path += user_exe_path;
 258                     FileSpec cwd_file (cwd_user_exe_path.c_str(), false);
 259                     if (cwd_file.Exists())
 260                         file = cwd_file;
 261                 }
 262             }
 263         }
 264
 265         ModuleSP exe_module_sp;
 266         if (platform_sp)
 267         {
 268             FileSpecList executable_search_paths (Target::GetDefaultExecutableSearchPaths());
 269             error = platform_sp->ResolveExecutable (file,
 270                                                     arch,
 271                                                     exe_module_sp,
 272                                                     executable_search_paths.GetSize() ? &executable_search_paths : NULL);
 273         }
 274
 275         if (error.Success() && exe_module_sp)
 276         {
 277             if (exe_module_sp->GetObjectFile() == NULL)
 278             {
 279                 if (arch.IsValid())
 280                 {
 281                     error.SetErrorStringWithFormat("\"%s\" doesn't contain architecture %s",
 282                                                    file.GetPath().c_str(),
 283                                                    arch.GetArchitectureName());
 284                 }
 285                 else
 286                 {
 287                     error.SetErrorStringWithFormat("unsupported file type \"%s\"",
 288                                                    file.GetPath().c_str());
 289                 }
 290                 return error;
 291             }
 292             target_sp.reset(new Target(debugger, arch, platform_sp));
 293             target_sp->SetExecutableModule (exe_module_sp, get_dependent_files);
 294             if (user_exe_path_is_bundle)
 295                 exe_module_sp->GetFileSpec().GetPath(resolved_bundle_exe_path, sizeof(resolved_bundle_exe_path));
 296         }
 297     }
 298     else
 299     {
 300         // No file was specified, just create an empty target with any arch
 301         // if a valid arch was specified
 302         target_sp.reset(new Target(debugger, arch, platform_sp));
 303     }
 304
 305     if (target_sp)
 306     {
 307         // Set argv0 with what the user typed, unless the user specified a
 308         // directory. If the user specified a directory, then it is probably a
 309         // bundle that was resolved and we need to use the resolved bundle path
 310         if (user_exe_path)
 311         {
 312             // Use exactly what the user typed as the first argument when we exec or posix_spawn
 313             if (user_exe_path_is_bundle && resolved_bundle_exe_path[0])
 314             {
 315                 target_sp->SetArg0 (resolved_bundle_exe_path);
 316             }
 317             else
 318             {
 319                 // Use resolved path
 320                 target_sp->SetArg0 (file.GetPath().c_str());
 321             }
 322         }
 323         if (file.GetDirectory())
 324         {
 325             FileSpec file_dir;
 326             file_dir.GetDirectory() = file.GetDirectory();
 327             target_sp->GetExecutableSearchPaths ().Append (file_dir);
 328         }
 329         Mutex::Locker locker(m_target_list_mutex);
 330         m_selected_target_idx = m_target_list.size();
 331         m_target_list.push_back(target_sp);
 332
 333
 334     }
 335
 336     return error;
 337 }
 338
 339 bool
 340 TargetList::DeleteTarget (TargetSP &target_sp)
 341 {
 342     Mutex::Locker locker(m_target_list_mutex);
 343     collection::iterator pos, end = m_target_list.end();
 344
 345     for (pos = m_target_list.begin(); pos != end; ++pos)
 346     {
 347         if (pos->get() == target_sp.get())
 348         {
 349             m_target_list.erase(pos);
 350             return true;
 351         }
 352     }
 353     return false;
 354 }
 355
 356
 357 TargetSP
 358 TargetList::FindTargetWithExecutableAndArchitecture
 359 (
 360     const FileSpec &exe_file_spec,
 361     const ArchSpec *exe_arch_ptr
 362 ) const
 363 {
 364     Mutex::Locker locker (m_target_list_mutex);
 365     TargetSP target_sp;
 366     bool full_match = exe_file_spec.GetDirectory();
 367
 368     collection::const_iterator pos, end = m_target_list.end();
 369     for (pos = m_target_list.begin(); pos != end; ++pos)
 370     {
 371         Module *exe_module = (*pos)->GetExecutableModulePointer();
 372
 373         if (exe_module)
 374         {
 375             if (FileSpec::Equal (exe_file_spec, exe_module->GetFileSpec(), full_match))
 376             {
 377                 if (exe_arch_ptr)
 378                 {
 379                     if (!exe_arch_ptr->IsCompatibleMatch(exe_module->GetArchitecture()))
 380                         continue;
 381                 }
 382                 target_sp = *pos;
 383                 break;
 384             }
 385         }
 386     }
 387     return target_sp;
 388 }
 389
 390 TargetSP
 391 TargetList::FindTargetWithProcessID (lldb::pid_t pid) const
 392 {
 393     Mutex::Locker locker(m_target_list_mutex);
 394     TargetSP target_sp;
 395     collection::const_iterator pos, end = m_target_list.end();
 396     for (pos = m_target_list.begin(); pos != end; ++pos)
 397     {
 398         Process* process = (*pos)->GetProcessSP().get();
 399         if (process && process->GetID() == pid)
 400         {
 401             target_sp = *pos;
 402             break;
 403         }
 404     }
 405     return target_sp;
 406 }
 407
 408
 409 TargetSP
 410 TargetList::FindTargetWithProcess (Process *process) const
 411 {
 412     TargetSP target_sp;
 413     if (process)
 414     {
 415         Mutex::Locker locker(m_target_list_mutex);
 416         collection::const_iterator pos, end = m_target_list.end();
 417         for (pos = m_target_list.begin(); pos != end; ++pos)
 418         {
 419             if (process == (*pos)->GetProcessSP().get())
 420             {
 421                 target_sp = *pos;
 422                 break;
 423             }
 424         }
 425     }
 426     return target_sp;
 427 }
 428
 429 TargetSP
 430 TargetList::GetTargetSP (Target *target) const
 431 {
 432     TargetSP target_sp;
 433     if (target)
 434     {
 435         Mutex::Locker locker(m_target_list_mutex);
 436         collection::const_iterator pos, end = m_target_list.end();
 437         for (pos = m_target_list.begin(); pos != end; ++pos)
 438         {
 439             if (target == (*pos).get())
 440             {
 441                 target_sp = *pos;
 442                 break;
 443             }
 444         }
 445     }
 446     return target_sp;
 447 }
 448
 449 uint32_t
 450 TargetList::SendAsyncInterrupt (lldb::pid_t pid)
 451 {
 452     uint32_t num_async_interrupts_sent = 0;
 453
 454     if (pid != LLDB_INVALID_PROCESS_ID)
 455     {
 456         TargetSP target_sp(FindTargetWithProcessID (pid));
 457         if (target_sp.get())
 458         {
 459             Process* process = target_sp->GetProcessSP().get();
 460             if (process)
 461             {
 462                 process->SendAsyncInterrupt();
 463                 ++num_async_interrupts_sent;
 464             }
 465         }
 466     }
 467     else
 468     {
 469         // We don't have a valid pid to broadcast to, so broadcast to the target
 470         // list's async broadcaster...
 471         BroadcastEvent (Process::eBroadcastBitInterrupt, NULL);
 472     }
 473
 474     return num_async_interrupts_sent;
 475 }
 476
 477 uint32_t
 478 TargetList::SignalIfRunning (lldb::pid_t pid, int signo)
 479 {
 480     uint32_t num_signals_sent = 0;
 481     Process *process = NULL;
 482     if (pid == LLDB_INVALID_PROCESS_ID)
 483     {
 484         // Signal all processes with signal
 485         Mutex::Locker locker(m_target_list_mutex);
 486         collection::iterator pos, end = m_target_list.end();
 487         for (pos = m_target_list.begin(); pos != end; ++pos)
 488         {
 489             process = (*pos)->GetProcessSP().get();
 490             if (process)
 491             {
 492                 if (process->IsAlive())
 493                 {
 494                     ++num_signals_sent;
 495                     process->Signal (signo);
 496                 }
 497             }
 498         }
 499     }
 500     else
 501     {
 502         // Signal a specific process with signal
 503         TargetSP target_sp(FindTargetWithProcessID (pid));
 504         if (target_sp.get())
 505         {
 506             process = target_sp->GetProcessSP().get();
 507             if (process)
 508             {
 509                 if (process->IsAlive())
 510                 {
 511                     ++num_signals_sent;
 512                     process->Signal (signo);
 513                 }
 514             }
 515         }
 516     }
 517     return num_signals_sent;
 518 }
 519
 520 int
 521 TargetList::GetNumTargets () const
 522 {
 523     Mutex::Locker locker (m_target_list_mutex);
 524     return m_target_list.size();
 525 }
 526
 527 lldb::TargetSP
 528 TargetList::GetTargetAtIndex (uint32_t idx) const
 529 {
 530     TargetSP target_sp;
 531     Mutex::Locker locker (m_target_list_mutex);
 532     if (idx < m_target_list.size())
 533         target_sp = m_target_list[idx];
 534     return target_sp;
 535 }
 536
 537 uint32_t
 538 TargetList::GetIndexOfTarget (lldb::TargetSP target_sp) const
 539 {
 540     Mutex::Locker locker (m_target_list_mutex);
 541     size_t num_targets = m_target_list.size();
 542     for (size_t idx = 0; idx < num_targets; idx++)
 543     {
 544         if (target_sp == m_target_list[idx])
 545             return idx;
 546     }
 547     return UINT32_MAX;
 548 }
 549
 550 uint32_t
 551 TargetList::SetSelectedTarget (Target* target)
 552 {
 553     Mutex::Locker locker (m_target_list_mutex);
 554     collection::const_iterator pos,
 555         begin = m_target_list.begin(),
 556         end = m_target_list.end();
 557     for (pos = begin; pos != end; ++pos)
 558     {
 559         if (pos->get() == target)
 560         {
 561             m_selected_target_idx = std::distance (begin, pos);
 562             return m_selected_target_idx;
 563         }
 564     }
 565     m_selected_target_idx = 0;
 566     return m_selected_target_idx;
 567 }
 568
 569 lldb::TargetSP
 570 TargetList::GetSelectedTarget ()
 571 {
 572     Mutex::Locker locker (m_target_list_mutex);
 573     if (m_selected_target_idx >= m_target_list.size())
 574         m_selected_target_idx = 0;
 575     return GetTargetAtIndex (m_selected_target_idx);
 576 }