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

   1 //===-- Platform.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/Platform.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Breakpoint/BreakpointIDList.h"
  17 #include "lldb/Core/Error.h"
  18 #include "lldb/Core/Log.h"
  19 #include "lldb/Core/ModuleSpec.h"
  20 #include "lldb/Core/PluginManager.h"
  21 #include "lldb/Host/FileSpec.h"
  22 #include "lldb/Host/Host.h"
  23 #include "lldb/Target/Process.h"
  24 #include "lldb/Target/Target.h"
  25 #include "lldb/Utility/Utils.h"
  26
  27 using namespace lldb;
  28 using namespace lldb_private;
  29
  30 // Use a singleton function for g_local_platform_sp to avoid init
  31 // constructors since LLDB is often part of a shared library
  32 static PlatformSP&
  33 GetDefaultPlatformSP ()
  34 {
  35     static PlatformSP g_default_platform_sp;
  36     return g_default_platform_sp;
  37 }
  38
  39 static Mutex &
  40 GetConnectedPlatformListMutex ()
  41 {
  42     static Mutex g_remote_connected_platforms_mutex (Mutex::eMutexTypeRecursive);
  43     return g_remote_connected_platforms_mutex;
  44 }
  45 static std::vector<PlatformSP> &
  46 GetConnectedPlatformList ()
  47 {
  48     static std::vector<PlatformSP> g_remote_connected_platforms;
  49     return g_remote_connected_platforms;
  50 }
  51
  52
  53 const char *
  54 Platform::GetHostPlatformName ()
  55 {
  56     return "host";
  57 }
  58
  59 //------------------------------------------------------------------
  60 /// Get the native host platform plug-in.
  61 ///
  62 /// There should only be one of these for each host that LLDB runs
  63 /// upon that should be statically compiled in and registered using
  64 /// preprocessor macros or other similar build mechanisms.
  65 ///
  66 /// This platform will be used as the default platform when launching
  67 /// or attaching to processes unless another platform is specified.
  68 //------------------------------------------------------------------
  69 PlatformSP
  70 Platform::GetDefaultPlatform ()
  71 {
  72     return GetDefaultPlatformSP ();
  73 }
  74
  75 void
  76 Platform::SetDefaultPlatform (const lldb::PlatformSP &platform_sp)
  77 {
  78     // The native platform should use its static void Platform::Initialize()
  79     // function to register itself as the native platform.
  80     GetDefaultPlatformSP () = platform_sp;
  81 }
  82
  83 Error
  84 Platform::GetFileWithUUID (const FileSpec &platform_file,
  85                            const UUID *uuid_ptr,
  86                            FileSpec &local_file)
  87 {
  88     // Default to the local case
  89     local_file = platform_file;
  90     return Error();
  91 }
  92
  93 FileSpecList
  94 Platform::LocateExecutableScriptingResources (Target *target, Module &module)
  95 {
  96     return FileSpecList();
  97 }
  98
  99 Platform*
 100 Platform::FindPlugin (Process *process, const ConstString &plugin_name)
 101 {
 102     PlatformCreateInstance create_callback = NULL;
 103     if (plugin_name)
 104     {
 105         create_callback  = PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name);
 106         if (create_callback)
 107         {
 108             ArchSpec arch;
 109             if (process)
 110             {
 111                 arch = process->GetTarget().GetArchitecture();
 112             }
 113             std::unique_ptr<Platform> instance_ap(create_callback(process, &arch));
 114             if (instance_ap.get())
 115                 return instance_ap.release();
 116         }
 117     }
 118     else
 119     {
 120         for (uint32_t idx = 0; (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx)) != NULL; ++idx)
 121         {
 122             std::unique_ptr<Platform> instance_ap(create_callback(process, nullptr));
 123             if (instance_ap.get())
 124                 return instance_ap.release();
 125         }
 126     }
 127     return NULL;
 128 }
 129
 130 Error
 131 Platform::GetSharedModule (const ModuleSpec &module_spec,
 132                            ModuleSP &module_sp,
 133                            const FileSpecList *module_search_paths_ptr,
 134                            ModuleSP *old_module_sp_ptr,
 135                            bool *did_create_ptr)
 136 {
 137     // Don't do any path remapping for the default implementation
 138     // of the platform GetSharedModule function, just call through
 139     // to our static ModuleList function. Platform subclasses that
 140     // implement remote debugging, might have a developer kits
 141     // installed that have cached versions of the files for the
 142     // remote target, or might implement a download and cache
 143     // locally implementation.
 144     const bool always_create = false;
 145     return ModuleList::GetSharedModule (module_spec,
 146                                         module_sp,
 147                                         module_search_paths_ptr,
 148                                         old_module_sp_ptr,
 149                                         did_create_ptr,
 150                                         always_create);
 151 }
 152
 153 PlatformSP
 154 Platform::Create (const char *platform_name, Error &error)
 155 {
 156     PlatformCreateInstance create_callback = NULL;
 157     lldb::PlatformSP platform_sp;
 158     if (platform_name && platform_name[0])
 159     {
 160         ConstString const_platform_name (platform_name);
 161         create_callback = PluginManager::GetPlatformCreateCallbackForPluginName (const_platform_name);
 162         if (create_callback)
 163             platform_sp.reset(create_callback(true, NULL));
 164         else
 165             error.SetErrorStringWithFormat ("unable to find a plug-in for the platform named \"%s\"", platform_name);
 166     }
 167     else
 168         error.SetErrorString ("invalid platform name");
 169     return platform_sp;
 170 }
 171
 172
 173 PlatformSP
 174 Platform::Create (const ArchSpec &arch, ArchSpec *platform_arch_ptr, Error &error)
 175 {
 176     lldb::PlatformSP platform_sp;
 177     if (arch.IsValid())
 178     {
 179         uint32_t idx;
 180         PlatformCreateInstance create_callback;
 181         // First try exact arch matches across all platform plug-ins
 182         bool exact = true;
 183         for (idx = 0; (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex (idx)); ++idx)
 184         {
 185             if (create_callback)
 186             {
 187                 platform_sp.reset(create_callback(false, &arch));
 188                 if (platform_sp && platform_sp->IsCompatibleArchitecture(arch, exact, platform_arch_ptr))
 189                     return platform_sp;
 190             }
 191         }
 192         // Next try compatible arch matches across all platform plug-ins
 193         exact = false;
 194         for (idx = 0; (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex (idx)); ++idx)
 195         {
 196             if (create_callback)
 197             {
 198                 platform_sp.reset(create_callback(false, &arch));
 199                 if (platform_sp && platform_sp->IsCompatibleArchitecture(arch, exact, platform_arch_ptr))
 200                     return platform_sp;
 201             }
 202         }
 203     }
 204     else
 205         error.SetErrorString ("invalid platform name");
 206     if (platform_arch_ptr)
 207         platform_arch_ptr->Clear();
 208     platform_sp.reset();
 209     return platform_sp;
 210 }
 211
 212 uint32_t
 213 Platform::GetNumConnectedRemotePlatforms ()
 214 {
 215     Mutex::Locker locker (GetConnectedPlatformListMutex ());
 216     return GetConnectedPlatformList().size();
 217 }
 218
 219 PlatformSP
 220 Platform::GetConnectedRemotePlatformAtIndex (uint32_t idx)
 221 {
 222     PlatformSP platform_sp;
 223     {
 224         Mutex::Locker locker (GetConnectedPlatformListMutex ());
 225         if (idx < GetConnectedPlatformList().size())
 226             platform_sp = GetConnectedPlatformList ()[idx];
 227     }
 228     return platform_sp;
 229 }
 230
 231 //------------------------------------------------------------------
 232 /// Default Constructor
 233 //------------------------------------------------------------------
 234 Platform::Platform (bool is_host) :
 235     m_is_host (is_host),
 236     m_os_version_set_while_connected (false),
 237     m_system_arch_set_while_connected (false),
 238     m_sdk_sysroot (),
 239     m_sdk_build (),
 240     m_working_dir (),
 241     m_remote_url (),
 242     m_name (),
 243     m_major_os_version (UINT32_MAX),
 244     m_minor_os_version (UINT32_MAX),
 245     m_update_os_version (UINT32_MAX),
 246     m_system_arch(),
 247     m_uid_map_mutex (Mutex::eMutexTypeNormal),
 248     m_gid_map_mutex (Mutex::eMutexTypeNormal),
 249     m_uid_map(),
 250     m_gid_map(),
 251     m_max_uid_name_len (0),
 252     m_max_gid_name_len (0),
 253     m_supports_rsync (false),
 254     m_rsync_opts (),
 255     m_rsync_prefix (),
 256     m_supports_ssh (false),
 257     m_ssh_opts (),
 258     m_ignores_remote_hostname (false),
 259     m_trap_handlers(),
 260     m_calculated_trap_handlers (false)
 261 {
 262     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
 263     if (log)
 264         log->Printf ("%p Platform::Platform()", this);
 265 }
 266
 267 //------------------------------------------------------------------
 268 /// Destructor.
 269 ///
 270 /// The destructor is virtual since this class is designed to be
 271 /// inherited from by the plug-in instance.
 272 //------------------------------------------------------------------
 273 Platform::~Platform()
 274 {
 275     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
 276     if (log)
 277         log->Printf ("%p Platform::~Platform()", this);
 278 }
 279
 280 void
 281 Platform::GetStatus (Stream &strm)
 282 {
 283     uint32_t major = UINT32_MAX;
 284     uint32_t minor = UINT32_MAX;
 285     uint32_t update = UINT32_MAX;
 286     std::string s;
 287     strm.Printf ("  Platform: %s\n", GetPluginName().GetCString());
 288
 289     ArchSpec arch (GetSystemArchitecture());
 290     if (arch.IsValid())
 291     {
 292         if (!arch.GetTriple().str().empty())
 293         strm.Printf("    Triple: %s\n", arch.GetTriple().str().c_str());
 294     }
 295
 296     if (GetOSVersion(major, minor, update))
 297     {
 298         strm.Printf("OS Version: %u", major);
 299         if (minor != UINT32_MAX)
 300             strm.Printf(".%u", minor);
 301         if (update != UINT32_MAX)
 302             strm.Printf(".%u", update);
 303
 304         if (GetOSBuildString (s))
 305             strm.Printf(" (%s)", s.c_str());
 306
 307         strm.EOL();
 308     }
 309
 310     if (GetOSKernelDescription (s))
 311         strm.Printf("    Kernel: %s\n", s.c_str());
 312
 313     if (IsHost())
 314     {
 315         strm.Printf("  Hostname: %s\n", GetHostname());
 316     }
 317     else
 318     {
 319         const bool is_connected = IsConnected();
 320         if (is_connected)
 321             strm.Printf("  Hostname: %s\n", GetHostname());
 322         strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
 323     }
 324
 325     if (GetWorkingDirectory())
 326     {
 327         strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
 328     }
 329     if (!IsConnected())
 330         return;
 331
 332     std::string specific_info(GetPlatformSpecificConnectionInformation());
 333
 334     if (specific_info.empty() == false)
 335         strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
 336 }
 337
 338
 339 bool
 340 Platform::GetOSVersion (uint32_t &major,
 341                         uint32_t &minor,
 342                         uint32_t &update)
 343 {
 344     bool success = m_major_os_version != UINT32_MAX;
 345     if (IsHost())
 346     {
 347         if (!success)
 348         {
 349             // We have a local host platform
 350             success = Host::GetOSVersion (m_major_os_version,
 351                                           m_minor_os_version,
 352                                           m_update_os_version);
 353             m_os_version_set_while_connected = success;
 354         }
 355     }
 356     else
 357     {
 358         // We have a remote platform. We can only fetch the remote
 359         // OS version if we are connected, and we don't want to do it
 360         // more than once.
 361
 362         const bool is_connected = IsConnected();
 363
 364         bool fetch = false;
 365         if (success)
 366         {
 367             // We have valid OS version info, check to make sure it wasn't
 368             // manually set prior to connecting. If it was manually set prior
 369             // to connecting, then lets fetch the actual OS version info
 370             // if we are now connected.
 371             if (is_connected && !m_os_version_set_while_connected)
 372                 fetch = true;
 373         }
 374         else
 375         {
 376             // We don't have valid OS version info, fetch it if we are connected
 377             fetch = is_connected;
 378         }
 379
 380         if (fetch)
 381         {
 382             success = GetRemoteOSVersion ();
 383             m_os_version_set_while_connected = success;
 384         }
 385     }
 386
 387     if (success)
 388     {
 389         major = m_major_os_version;
 390         minor = m_minor_os_version;
 391         update = m_update_os_version;
 392     }
 393     return success;
 394 }
 395
 396 bool
 397 Platform::GetOSBuildString (std::string &s)
 398 {
 399     if (IsHost())
 400         return Host::GetOSBuildString (s);
 401     else
 402         return GetRemoteOSBuildString (s);
 403 }
 404
 405 bool
 406 Platform::GetOSKernelDescription (std::string &s)
 407 {
 408     if (IsHost())
 409         return Host::GetOSKernelDescription (s);
 410     else
 411         return GetRemoteOSKernelDescription (s);
 412 }
 413
 414 ConstString
 415 Platform::GetWorkingDirectory ()
 416 {
 417     if (IsHost())
 418     {
 419         char cwd[PATH_MAX];
 420         if (getcwd(cwd, sizeof(cwd)))
 421             return ConstString(cwd);
 422         else
 423             return ConstString();
 424     }
 425     else
 426     {
 427         if (!m_working_dir)
 428             m_working_dir = GetRemoteWorkingDirectory();
 429         return m_working_dir;
 430     }
 431 }
 432
 433
 434 struct RecurseCopyBaton
 435 {
 436     const FileSpec& dst;
 437     Platform *platform_ptr;
 438     Error error;
 439 };
 440
 441
 442 static FileSpec::EnumerateDirectoryResult
 443 RecurseCopy_Callback (void *baton,
 444                       FileSpec::FileType file_type,
 445                       const FileSpec &src)
 446 {
 447     RecurseCopyBaton* rc_baton = (RecurseCopyBaton*)baton;
 448     switch (file_type)
 449     {
 450         case FileSpec::eFileTypePipe:
 451         case FileSpec::eFileTypeSocket:
 452             // we have no way to copy pipes and sockets - ignore them and continue
 453             return FileSpec::eEnumerateDirectoryResultNext;
 454             break;
 455
 456         case FileSpec::eFileTypeDirectory:
 457             {
 458                 // make the new directory and get in there
 459                 FileSpec dst_dir = rc_baton->dst;
 460                 if (!dst_dir.GetFilename())
 461                     dst_dir.GetFilename() = src.GetLastPathComponent();
 462                 std::string dst_dir_path (dst_dir.GetPath());
 463                 Error error = rc_baton->platform_ptr->MakeDirectory(dst_dir_path.c_str(), lldb::eFilePermissionsDirectoryDefault);
 464                 if (error.Fail())
 465                 {
 466                     rc_baton->error.SetErrorStringWithFormat("unable to setup directory %s on remote end", dst_dir_path.c_str());
 467                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 468                 }
 469
 470                 // now recurse
 471                 std::string src_dir_path (src.GetPath());
 472
 473                 // Make a filespec that only fills in the directory of a FileSpec so
 474                 // when we enumerate we can quickly fill in the filename for dst copies
 475                 FileSpec recurse_dst;
 476                 recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
 477                 RecurseCopyBaton rc_baton2 = { recurse_dst, rc_baton->platform_ptr, Error() };
 478                 FileSpec::EnumerateDirectory(src_dir_path.c_str(), true, true, true, RecurseCopy_Callback, &rc_baton2);
 479                 if (rc_baton2.error.Fail())
 480                 {
 481                     rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
 482                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 483                 }
 484                 return FileSpec::eEnumerateDirectoryResultNext;
 485             }
 486             break;
 487
 488         case FileSpec::eFileTypeSymbolicLink:
 489             {
 490                 // copy the file and keep going
 491                 FileSpec dst_file = rc_baton->dst;
 492                 if (!dst_file.GetFilename())
 493                     dst_file.GetFilename() = src.GetFilename();
 494
 495                 char buf[PATH_MAX];
 496
 497                 rc_baton->error = Host::Readlink (src.GetPath().c_str(), buf, sizeof(buf));
 498
 499                 if (rc_baton->error.Fail())
 500                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 501
 502                 rc_baton->error = rc_baton->platform_ptr->CreateSymlink(dst_file.GetPath().c_str(), buf);
 503
 504                 if (rc_baton->error.Fail())
 505                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 506
 507                 return FileSpec::eEnumerateDirectoryResultNext;
 508             }
 509             break;
 510         case FileSpec::eFileTypeRegular:
 511             {
 512                 // copy the file and keep going
 513                 FileSpec dst_file = rc_baton->dst;
 514                 if (!dst_file.GetFilename())
 515                     dst_file.GetFilename() = src.GetFilename();
 516                 Error err = rc_baton->platform_ptr->PutFile(src, dst_file);
 517                 if (err.Fail())
 518                 {
 519                     rc_baton->error.SetErrorString(err.AsCString());
 520                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 521                 }
 522                 return FileSpec::eEnumerateDirectoryResultNext;
 523             }
 524             break;
 525
 526         case FileSpec::eFileTypeInvalid:
 527         case FileSpec::eFileTypeOther:
 528         case FileSpec::eFileTypeUnknown:
 529             rc_baton->error.SetErrorStringWithFormat("invalid file detected during copy: %s", src.GetPath().c_str());
 530             return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 531             break;
 532     }
 533 }
 534
 535 Error
 536 Platform::Install (const FileSpec& src, const FileSpec& dst)
 537 {
 538     Error error;
 539
 540     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 541     if (log)
 542         log->Printf ("Platform::Install (src='%s', dst='%s')", src.GetPath().c_str(), dst.GetPath().c_str());
 543     FileSpec fixed_dst(dst);
 544
 545     if (!fixed_dst.GetFilename())
 546         fixed_dst.GetFilename() = src.GetFilename();
 547
 548     ConstString working_dir = GetWorkingDirectory();
 549
 550     if (dst)
 551     {
 552         if (dst.GetDirectory())
 553         {
 554             const char first_dst_dir_char = dst.GetDirectory().GetCString()[0];
 555             if (first_dst_dir_char == '/' || first_dst_dir_char  == '\\')
 556             {
 557                 fixed_dst.GetDirectory() = dst.GetDirectory();
 558             }
 559             // If the fixed destination file doesn't have a directory yet,
 560             // then we must have a relative path. We will resolve this relative
 561             // path against the platform's working directory
 562             if (!fixed_dst.GetDirectory())
 563             {
 564                 FileSpec relative_spec;
 565                 std::string path;
 566                 if (working_dir)
 567                 {
 568                     relative_spec.SetFile(working_dir.GetCString(), false);
 569                     relative_spec.AppendPathComponent(dst.GetPath().c_str());
 570                     fixed_dst.GetDirectory() = relative_spec.GetDirectory();
 571                 }
 572                 else
 573                 {
 574                     error.SetErrorStringWithFormat("platform working directory must be valid for relative path '%s'", dst.GetPath().c_str());
 575                     return error;
 576                 }
 577             }
 578         }
 579         else
 580         {
 581             if (working_dir)
 582             {
 583                 fixed_dst.GetDirectory() = working_dir;
 584             }
 585             else
 586             {
 587                 error.SetErrorStringWithFormat("platform working directory must be valid for relative path '%s'", dst.GetPath().c_str());
 588                 return error;
 589             }
 590         }
 591     }
 592     else
 593     {
 594         if (working_dir)
 595         {
 596             fixed_dst.GetDirectory() = working_dir;
 597         }
 598         else
 599         {
 600             error.SetErrorStringWithFormat("platform working directory must be valid when destination directory is empty");
 601             return error;
 602         }
 603     }
 604
 605     if (log)
 606         log->Printf ("Platform::Install (src='%s', dst='%s') fixed_dst='%s'", src.GetPath().c_str(), dst.GetPath().c_str(), fixed_dst.GetPath().c_str());
 607
 608     if (GetSupportsRSync())
 609     {
 610         error = PutFile(src, dst);
 611     }
 612     else
 613     {
 614         switch (src.GetFileType())
 615         {
 616             case FileSpec::eFileTypeDirectory:
 617                 {
 618                     if (GetFileExists (fixed_dst))
 619                         Unlink (fixed_dst.GetPath().c_str());
 620                     uint32_t permissions = src.GetPermissions();
 621                     if (permissions == 0)
 622                         permissions = eFilePermissionsDirectoryDefault;
 623                     std::string dst_dir_path(fixed_dst.GetPath());
 624                     error = MakeDirectory(dst_dir_path.c_str(), permissions);
 625                     if (error.Success())
 626                     {
 627                         // Make a filespec that only fills in the directory of a FileSpec so
 628                         // when we enumerate we can quickly fill in the filename for dst copies
 629                         FileSpec recurse_dst;
 630                         recurse_dst.GetDirectory().SetCString(dst_dir_path.c_str());
 631                         std::string src_dir_path (src.GetPath());
 632                         RecurseCopyBaton baton = { recurse_dst, this, Error() };
 633                         FileSpec::EnumerateDirectory(src_dir_path.c_str(), true, true, true, RecurseCopy_Callback, &baton);
 634                         return baton.error;
 635                     }
 636                 }
 637                 break;
 638
 639             case FileSpec::eFileTypeRegular:
 640                 if (GetFileExists (fixed_dst))
 641                     Unlink (fixed_dst.GetPath().c_str());
 642                 error = PutFile(src, fixed_dst);
 643                 break;
 644
 645             case FileSpec::eFileTypeSymbolicLink:
 646                 {
 647                     if (GetFileExists (fixed_dst))
 648                         Unlink (fixed_dst.GetPath().c_str());
 649                     char buf[PATH_MAX];
 650                     error = Host::Readlink(src.GetPath().c_str(), buf, sizeof(buf));
 651                     if (error.Success())
 652                         error = CreateSymlink(dst.GetPath().c_str(), buf);
 653                 }
 654                 break;
 655             case FileSpec::eFileTypePipe:
 656                 error.SetErrorString("platform install doesn't handle pipes");
 657                 break;
 658             case FileSpec::eFileTypeSocket:
 659                 error.SetErrorString("platform install doesn't handle sockets");
 660                 break;
 661             case FileSpec::eFileTypeInvalid:
 662             case FileSpec::eFileTypeUnknown:
 663             case FileSpec::eFileTypeOther:
 664                 error.SetErrorString("platform install doesn't handle non file or directory items");
 665                 break;
 666         }
 667     }
 668     return error;
 669 }
 670
 671 bool
 672 Platform::SetWorkingDirectory (const ConstString &path)
 673 {
 674     if (IsHost())
 675     {
 676         Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 677         if (log)
 678             log->Printf("Platform::SetWorkingDirectory('%s')", path.GetCString());
 679 #ifdef _WIN32
 680         // Not implemented on Windows
 681         return false;
 682 #else
 683         if (path)
 684         {
 685             if (chdir(path.GetCString()) == 0)
 686                 return true;
 687         }
 688         return false;
 689 #endif
 690     }
 691     else
 692     {
 693         m_working_dir.Clear();
 694         return SetRemoteWorkingDirectory(path);
 695     }
 696 }
 697
 698 Error
 699 Platform::MakeDirectory (const char *path, uint32_t permissions)
 700 {
 701     if (IsHost())
 702         return Host::MakeDirectory (path, permissions);
 703     else
 704     {
 705         Error error;
 706         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
 707         return error;
 708     }
 709 }
 710
 711 Error
 712 Platform::GetFilePermissions (const char *path, uint32_t &file_permissions)
 713 {
 714     if (IsHost())
 715         return Host::GetFilePermissions(path, file_permissions);
 716     else
 717     {
 718         Error error;
 719         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
 720         return error;
 721     }
 722 }
 723
 724 Error
 725 Platform::SetFilePermissions (const char *path, uint32_t file_permissions)
 726 {
 727     if (IsHost())
 728         return Host::SetFilePermissions(path, file_permissions);
 729     else
 730     {
 731         Error error;
 732         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
 733         return error;
 734     }
 735 }
 736
 737 ConstString
 738 Platform::GetName ()
 739 {
 740     return GetPluginName();
 741 }
 742
 743 const char *
 744 Platform::GetHostname ()
 745 {
 746     if (IsHost())
 747         return "localhost";
 748
 749     if (m_name.empty())
 750         return NULL;
 751     return m_name.c_str();
 752 }
 753
 754 bool
 755 Platform::SetRemoteWorkingDirectory(const ConstString &path)
 756 {
 757     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 758     if (log)
 759         log->Printf("Platform::SetRemoteWorkingDirectory('%s')", path.GetCString());
 760     m_working_dir = path;
 761     return true;
 762 }
 763
 764 const char *
 765 Platform::GetUserName (uint32_t uid)
 766 {
 767     const char *user_name = GetCachedUserName(uid);
 768     if (user_name)
 769         return user_name;
 770     if (IsHost())
 771     {
 772         std::string name;
 773         if (Host::GetUserName(uid, name))
 774             return SetCachedUserName (uid, name.c_str(), name.size());
 775     }
 776     return NULL;
 777 }
 778
 779 const char *
 780 Platform::GetGroupName (uint32_t gid)
 781 {
 782     const char *group_name = GetCachedGroupName(gid);
 783     if (group_name)
 784         return group_name;
 785     if (IsHost())
 786     {
 787         std::string name;
 788         if (Host::GetGroupName(gid, name))
 789             return SetCachedGroupName (gid, name.c_str(), name.size());
 790     }
 791     return NULL;
 792 }
 793
 794 bool
 795 Platform::SetOSVersion (uint32_t major,
 796                         uint32_t minor,
 797                         uint32_t update)
 798 {
 799     if (IsHost())
 800     {
 801         // We don't need anyone setting the OS version for the host platform,
 802         // we should be able to figure it out by calling Host::GetOSVersion(...).
 803         return false;
 804     }
 805     else
 806     {
 807         // We have a remote platform, allow setting the target OS version if
 808         // we aren't connected, since if we are connected, we should be able to
 809         // request the remote OS version from the connected platform.
 810         if (IsConnected())
 811             return false;
 812         else
 813         {
 814             // We aren't connected and we might want to set the OS version
 815             // ahead of time before we connect so we can peruse files and
 816             // use a local SDK or PDK cache of support files to disassemble
 817             // or do other things.
 818             m_major_os_version = major;
 819             m_minor_os_version = minor;
 820             m_update_os_version = update;
 821             return true;
 822         }
 823     }
 824     return false;
 825 }
 826
 827
 828 Error
 829 Platform::ResolveExecutable (const FileSpec &exe_file,
 830                              const ArchSpec &exe_arch,
 831                              lldb::ModuleSP &exe_module_sp,
 832                              const FileSpecList *module_search_paths_ptr)
 833 {
 834     Error error;
 835     if (exe_file.Exists())
 836     {
 837         ModuleSpec module_spec (exe_file, exe_arch);
 838         if (module_spec.GetArchitecture().IsValid())
 839         {
 840             error = ModuleList::GetSharedModule (module_spec,
 841                                                  exe_module_sp,
 842                                                  module_search_paths_ptr,
 843                                                  NULL,
 844                                                  NULL);
 845         }
 846         else
 847         {
 848             // No valid architecture was specified, ask the platform for
 849             // the architectures that we should be using (in the correct order)
 850             // and see if we can find a match that way
 851             for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, module_spec.GetArchitecture()); ++idx)
 852             {
 853                 error = ModuleList::GetSharedModule (module_spec,
 854                                                      exe_module_sp,
 855                                                      module_search_paths_ptr,
 856                                                      NULL,
 857                                                      NULL);
 858                 // Did we find an executable using one of the
 859                 if (error.Success() && exe_module_sp)
 860                     break;
 861             }
 862         }
 863     }
 864     else
 865     {
 866         error.SetErrorStringWithFormat ("'%s' does not exist",
 867                                         exe_file.GetPath().c_str());
 868     }
 869     return error;
 870 }
 871
 872 Error
 873 Platform::ResolveSymbolFile (Target &target,
 874                              const ModuleSpec &sym_spec,
 875                              FileSpec &sym_file)
 876 {
 877     Error error;
 878     if (sym_spec.GetSymbolFileSpec().Exists())
 879         sym_file = sym_spec.GetSymbolFileSpec();
 880     else
 881         error.SetErrorString("unable to resolve symbol file");
 882     return error;
 883
 884 }
 885
 886
 887
 888 bool
 889 Platform::ResolveRemotePath (const FileSpec &platform_path,
 890                              FileSpec &resolved_platform_path)
 891 {
 892     resolved_platform_path = platform_path;
 893     return resolved_platform_path.ResolvePath();
 894 }
 895
 896
 897 const ArchSpec &
 898 Platform::GetSystemArchitecture()
 899 {
 900     if (IsHost())
 901     {
 902         if (!m_system_arch.IsValid())
 903         {
 904             // We have a local host platform
 905             m_system_arch = Host::GetArchitecture();
 906             m_system_arch_set_while_connected = m_system_arch.IsValid();
 907         }
 908     }
 909     else
 910     {
 911         // We have a remote platform. We can only fetch the remote
 912         // system architecture if we are connected, and we don't want to do it
 913         // more than once.
 914
 915         const bool is_connected = IsConnected();
 916
 917         bool fetch = false;
 918         if (m_system_arch.IsValid())
 919         {
 920             // We have valid OS version info, check to make sure it wasn't
 921             // manually set prior to connecting. If it was manually set prior
 922             // to connecting, then lets fetch the actual OS version info
 923             // if we are now connected.
 924             if (is_connected && !m_system_arch_set_while_connected)
 925                 fetch = true;
 926         }
 927         else
 928         {
 929             // We don't have valid OS version info, fetch it if we are connected
 930             fetch = is_connected;
 931         }
 932
 933         if (fetch)
 934         {
 935             m_system_arch = GetRemoteSystemArchitecture ();
 936             m_system_arch_set_while_connected = m_system_arch.IsValid();
 937         }
 938     }
 939     return m_system_arch;
 940 }
 941
 942
 943 Error
 944 Platform::ConnectRemote (Args& args)
 945 {
 946     Error error;
 947     if (IsHost())
 948         error.SetErrorStringWithFormat ("The currently selected platform (%s) is the host platform and is always connected.", GetPluginName().GetCString());
 949     else
 950         error.SetErrorStringWithFormat ("Platform::ConnectRemote() is not supported by %s", GetPluginName().GetCString());
 951     return error;
 952 }
 953
 954 Error
 955 Platform::DisconnectRemote ()
 956 {
 957     Error error;
 958     if (IsHost())
 959         error.SetErrorStringWithFormat ("The currently selected platform (%s) is the host platform and is always connected.", GetPluginName().GetCString());
 960     else
 961         error.SetErrorStringWithFormat ("Platform::DisconnectRemote() is not supported by %s", GetPluginName().GetCString());
 962     return error;
 963 }
 964
 965 bool
 966 Platform::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
 967 {
 968     // Take care of the host case so that each subclass can just
 969     // call this function to get the host functionality.
 970     if (IsHost())
 971         return Host::GetProcessInfo (pid, process_info);
 972     return false;
 973 }
 974
 975 uint32_t
 976 Platform::FindProcesses (const ProcessInstanceInfoMatch &match_info,
 977                          ProcessInstanceInfoList &process_infos)
 978 {
 979     // Take care of the host case so that each subclass can just
 980     // call this function to get the host functionality.
 981     uint32_t match_count = 0;
 982     if (IsHost())
 983         match_count = Host::FindProcesses (match_info, process_infos);
 984     return match_count;
 985 }
 986
 987
 988 Error
 989 Platform::LaunchProcess (ProcessLaunchInfo &launch_info)
 990 {
 991     Error error;
 992     // Take care of the host case so that each subclass can just
 993     // call this function to get the host functionality.
 994     if (IsHost())
 995     {
 996         if (::getenv ("LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY"))
 997             launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY);
 998
 999         if (launch_info.GetFlags().Test (eLaunchFlagLaunchInShell))
1000         {
1001             const bool is_localhost = true;
1002             const bool will_debug = launch_info.GetFlags().Test(eLaunchFlagDebug);
1003             const bool first_arg_is_full_shell_command = false;
1004             uint32_t num_resumes = GetResumeCountForLaunchInfo (launch_info);
1005             if (!launch_info.ConvertArgumentsForLaunchingInShell (error,
1006                                                                   is_localhost,
1007                                                                   will_debug,
1008                                                                   first_arg_is_full_shell_command,
1009                                                                   num_resumes))
1010                 return error;
1011         }
1012
1013         error = Host::LaunchProcess (launch_info);
1014     }
1015     else
1016         error.SetErrorString ("base lldb_private::Platform class can't launch remote processes");
1017     return error;
1018 }
1019
1020 lldb::ProcessSP
1021 Platform::DebugProcess (ProcessLaunchInfo &launch_info,
1022                         Debugger &debugger,
1023                         Target *target,       // Can be NULL, if NULL create a new target, else use existing one
1024                         Listener &listener,
1025                         Error &error)
1026 {
1027     ProcessSP process_sp;
1028     // Make sure we stop at the entry point
1029     launch_info.GetFlags ().Set (eLaunchFlagDebug);
1030     // We always launch the process we are going to debug in a separate process
1031     // group, since then we can handle ^C interrupts ourselves w/o having to worry
1032     // about the target getting them as well.
1033     launch_info.SetLaunchInSeparateProcessGroup(true);
1034
1035     error = LaunchProcess (launch_info);
1036     if (error.Success())
1037     {
1038         if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
1039         {
1040             ProcessAttachInfo attach_info (launch_info);
1041             process_sp = Attach (attach_info, debugger, target, listener, error);
1042             if (process_sp)
1043             {
1044                 launch_info.SetHijackListener(attach_info.GetHijackListener());
1045
1046                 // Since we attached to the process, it will think it needs to detach
1047                 // if the process object just goes away without an explicit call to
1048                 // Process::Kill() or Process::Detach(), so let it know to kill the
1049                 // process if this happens.
1050                 process_sp->SetShouldDetach (false);
1051
1052                 // If we didn't have any file actions, the pseudo terminal might
1053                 // have been used where the slave side was given as the file to
1054                 // open for stdin/out/err after we have already opened the master
1055                 // so we can read/write stdin/out/err.
1056                 int pty_fd = launch_info.GetPTY().ReleaseMasterFileDescriptor();
1057                 if (pty_fd != lldb_utility::PseudoTerminal::invalid_fd)
1058                 {
1059                     process_sp->SetSTDIOFileDescriptor(pty_fd);
1060                 }
1061             }
1062         }
1063     }
1064     return process_sp;
1065 }
1066
1067
1068 lldb::PlatformSP
1069 Platform::GetPlatformForArchitecture (const ArchSpec &arch, ArchSpec *platform_arch_ptr)
1070 {
1071     lldb::PlatformSP platform_sp;
1072     Error error;
1073     if (arch.IsValid())
1074         platform_sp = Platform::Create (arch, platform_arch_ptr, error);
1075     return platform_sp;
1076 }
1077
1078
1079 //------------------------------------------------------------------
1080 /// Lets a platform answer if it is compatible with a given
1081 /// architecture and the target triple contained within.
1082 //------------------------------------------------------------------
1083 bool
1084 Platform::IsCompatibleArchitecture (const ArchSpec &arch, bool exact_arch_match, ArchSpec *compatible_arch_ptr)
1085 {
1086     // If the architecture is invalid, we must answer true...
1087     if (arch.IsValid())
1088     {
1089         ArchSpec platform_arch;
1090         // Try for an exact architecture match first.
1091         if (exact_arch_match)
1092         {
1093             for (uint32_t arch_idx=0; GetSupportedArchitectureAtIndex (arch_idx, platform_arch); ++arch_idx)
1094             {
1095                 if (arch.IsExactMatch(platform_arch))
1096                 {
1097                     if (compatible_arch_ptr)
1098                         *compatible_arch_ptr = platform_arch;
1099                     return true;
1100                 }
1101             }
1102         }
1103         else
1104         {
1105             for (uint32_t arch_idx=0; GetSupportedArchitectureAtIndex (arch_idx, platform_arch); ++arch_idx)
1106             {
1107                 if (arch.IsCompatibleMatch(platform_arch))
1108                 {
1109                     if (compatible_arch_ptr)
1110                         *compatible_arch_ptr = platform_arch;
1111                     return true;
1112                 }
1113             }
1114         }
1115     }
1116     if (compatible_arch_ptr)
1117         compatible_arch_ptr->Clear();
1118     return false;
1119 }
1120
1121 Error
1122 Platform::PutFile (const FileSpec& source,
1123                    const FileSpec& destination,
1124                    uint32_t uid,
1125                    uint32_t gid)
1126 {
1127     Error error("unimplemented");
1128     return error;
1129 }
1130
1131 Error
1132 Platform::GetFile (const FileSpec& source,
1133                    const FileSpec& destination)
1134 {
1135     Error error("unimplemented");
1136     return error;
1137 }
1138
1139 Error
1140 Platform::CreateSymlink (const char *src, // The name of the link is in src
1141                          const char *dst)// The symlink points to dst
1142 {
1143     Error error("unimplemented");
1144     return error;
1145 }
1146
1147 bool
1148 Platform::GetFileExists (const lldb_private::FileSpec& file_spec)
1149 {
1150     return false;
1151 }
1152
1153 Error
1154 Platform::Unlink (const char *path)
1155 {
1156     Error error("unimplemented");
1157     return error;
1158 }
1159
1160
1161
1162 lldb_private::Error
1163 Platform::RunShellCommand (const char *command,           // Shouldn't be NULL
1164                            const char *working_dir,       // Pass NULL to use the current working directory
1165                            int *status_ptr,               // Pass NULL if you don't want the process exit status
1166                            int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
1167                            std::string *command_output,   // Pass NULL if you don't want the command output
1168                            uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
1169 {
1170     if (IsHost())
1171         return Host::RunShellCommand (command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
1172     else
1173         return Error("unimplemented");
1174 }
1175
1176
1177 bool
1178 Platform::CalculateMD5 (const FileSpec& file_spec,
1179                         uint64_t &low,
1180                         uint64_t &high)
1181 {
1182     if (IsHost())
1183         return Host::CalculateMD5(file_spec, low, high);
1184     else
1185         return false;
1186 }
1187
1188 void
1189 Platform::SetLocalCacheDirectory (const char* local)
1190 {
1191     m_local_cache_directory.assign(local);
1192 }
1193
1194 const char*
1195 Platform::GetLocalCacheDirectory ()
1196 {
1197     return m_local_cache_directory.c_str();
1198 }
1199
1200 static OptionDefinition
1201 g_rsync_option_table[] =
1202 {
1203     {   LLDB_OPT_SET_ALL, false, "rsync"                  , 'r', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone         , "Enable rsync." },
1204     {   LLDB_OPT_SET_ALL, false, "rsync-opts"             , 'R', OptionParser::eRequiredArgument, NULL, 0, eArgTypeCommandName  , "Platform-specific options required for rsync to work." },
1205     {   LLDB_OPT_SET_ALL, false, "rsync-prefix"           , 'P', OptionParser::eRequiredArgument, NULL, 0, eArgTypeCommandName  , "Platform-specific rsync prefix put before the remote path." },
1206     {   LLDB_OPT_SET_ALL, false, "ignore-remote-hostname" , 'i', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone         , "Do not automatically fill in the remote hostname when composing the rsync command." },
1207 };
1208
1209 static OptionDefinition
1210 g_ssh_option_table[] =
1211 {
1212     {   LLDB_OPT_SET_ALL, false, "ssh"                    , 's', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone         , "Enable SSH." },
1213     {   LLDB_OPT_SET_ALL, false, "ssh-opts"               , 'S', OptionParser::eRequiredArgument, NULL, 0, eArgTypeCommandName  , "Platform-specific options required for SSH to work." },
1214 };
1215
1216 static OptionDefinition
1217 g_caching_option_table[] =
1218 {
1219     {   LLDB_OPT_SET_ALL, false, "local-cache-dir"        , 'c', OptionParser::eRequiredArgument, NULL, 0, eArgTypePath         , "Path in which to store local copies of files." },
1220 };
1221
1222 OptionGroupPlatformRSync::OptionGroupPlatformRSync ()
1223 {
1224 }
1225
1226 OptionGroupPlatformRSync::~OptionGroupPlatformRSync ()
1227 {
1228 }
1229
1230 const lldb_private::OptionDefinition*
1231 OptionGroupPlatformRSync::GetDefinitions ()
1232 {
1233     return g_rsync_option_table;
1234 }
1235
1236 void
1237 OptionGroupPlatformRSync::OptionParsingStarting (CommandInterpreter &interpreter)
1238 {
1239     m_rsync = false;
1240     m_rsync_opts.clear();
1241     m_rsync_prefix.clear();
1242     m_ignores_remote_hostname = false;
1243 }
1244
1245 lldb_private::Error
1246 OptionGroupPlatformRSync::SetOptionValue (CommandInterpreter &interpreter,
1247                 uint32_t option_idx,
1248                 const char *option_arg)
1249 {
1250     Error error;
1251     char short_option = (char) GetDefinitions()[option_idx].short_option;
1252     switch (short_option)
1253     {
1254         case 'r':
1255             m_rsync = true;
1256             break;
1257
1258         case 'R':
1259             m_rsync_opts.assign(option_arg);
1260             break;
1261
1262         case 'P':
1263             m_rsync_prefix.assign(option_arg);
1264             break;
1265
1266         case 'i':
1267             m_ignores_remote_hostname = true;
1268             break;
1269
1270         default:
1271             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1272             break;
1273     }
1274
1275     return error;
1276 }
1277
1278 uint32_t
1279 OptionGroupPlatformRSync::GetNumDefinitions ()
1280 {
1281     return llvm::array_lengthof(g_rsync_option_table);
1282 }
1283
1284 lldb::BreakpointSP
1285 Platform::SetThreadCreationBreakpoint (lldb_private::Target &target)
1286 {
1287     return lldb::BreakpointSP();
1288 }
1289
1290 OptionGroupPlatformSSH::OptionGroupPlatformSSH ()
1291 {
1292 }
1293
1294 OptionGroupPlatformSSH::~OptionGroupPlatformSSH ()
1295 {
1296 }
1297
1298 const lldb_private::OptionDefinition*
1299 OptionGroupPlatformSSH::GetDefinitions ()
1300 {
1301     return g_ssh_option_table;
1302 }
1303
1304 void
1305 OptionGroupPlatformSSH::OptionParsingStarting (CommandInterpreter &interpreter)
1306 {
1307     m_ssh = false;
1308     m_ssh_opts.clear();
1309 }
1310
1311 lldb_private::Error
1312 OptionGroupPlatformSSH::SetOptionValue (CommandInterpreter &interpreter,
1313                                           uint32_t option_idx,
1314                                           const char *option_arg)
1315 {
1316     Error error;
1317     char short_option = (char) GetDefinitions()[option_idx].short_option;
1318     switch (short_option)
1319     {
1320         case 's':
1321             m_ssh = true;
1322             break;
1323
1324         case 'S':
1325             m_ssh_opts.assign(option_arg);
1326             break;
1327
1328         default:
1329             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1330             break;
1331     }
1332
1333     return error;
1334 }
1335
1336 uint32_t
1337 OptionGroupPlatformSSH::GetNumDefinitions ()
1338 {
1339     return llvm::array_lengthof(g_ssh_option_table);
1340 }
1341
1342 OptionGroupPlatformCaching::OptionGroupPlatformCaching ()
1343 {
1344 }
1345
1346 OptionGroupPlatformCaching::~OptionGroupPlatformCaching ()
1347 {
1348 }
1349
1350 const lldb_private::OptionDefinition*
1351 OptionGroupPlatformCaching::GetDefinitions ()
1352 {
1353     return g_caching_option_table;
1354 }
1355
1356 void
1357 OptionGroupPlatformCaching::OptionParsingStarting (CommandInterpreter &interpreter)
1358 {
1359     m_cache_dir.clear();
1360 }
1361
1362 lldb_private::Error
1363 OptionGroupPlatformCaching::SetOptionValue (CommandInterpreter &interpreter,
1364                                         uint32_t option_idx,
1365                                         const char *option_arg)
1366 {
1367     Error error;
1368     char short_option = (char) GetDefinitions()[option_idx].short_option;
1369     switch (short_option)
1370     {
1371         case 'c':
1372             m_cache_dir.assign(option_arg);
1373             break;
1374
1375         default:
1376             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1377             break;
1378     }
1379
1380     return error;
1381 }
1382
1383 uint32_t
1384 OptionGroupPlatformCaching::GetNumDefinitions ()
1385 {
1386     return llvm::array_lengthof(g_caching_option_table);
1387 }
1388
1389 size_t
1390 Platform::GetEnvironment (StringList &environment)
1391 {
1392     environment.Clear();
1393     return false;
1394 }
1395
1396 const std::vector<ConstString> &
1397 Platform::GetTrapHandlerSymbolNames ()
1398 {
1399     if (!m_calculated_trap_handlers)
1400     {
1401         CalculateTrapHandlerSymbolNames();
1402         m_calculated_trap_handlers = true;
1403     }
1404     return m_trap_handlers;
1405 }
1406