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 // C Includes
  11 // C++ Includes
  12 #include <algorithm>
  13 #include <fstream>
  14 #include <vector>
  15
  16 // Other libraries and framework includes
  17 #include "llvm/Support/FileSystem.h"
  18 #include "llvm/Support/Path.h"
  19
  20 // Project includes
  21 #include "lldb/Target/Platform.h"
  22 #include "lldb/Breakpoint/BreakpointIDList.h"
  23 #include "lldb/Breakpoint/BreakpointLocation.h"
  24 #include "lldb/Core/DataBufferHeap.h"
  25 #include "lldb/Core/Debugger.h"
  26 #include "lldb/Core/Error.h"
  27 #include "lldb/Core/Log.h"
  28 #include "lldb/Core/Module.h"
  29 #include "lldb/Core/ModuleSpec.h"
  30 #include "lldb/Core/PluginManager.h"
  31 #include "lldb/Core/StreamFile.h"
  32 #include "lldb/Core/StructuredData.h"
  33 #include "lldb/Host/FileSpec.h"
  34 #include "lldb/Host/FileSystem.h"
  35 #include "lldb/Host/Host.h"
  36 #include "lldb/Host/HostInfo.h"
  37 #include "lldb/Interpreter/OptionValueProperties.h"
  38 #include "lldb/Interpreter/Property.h"
  39 #include "lldb/Symbol/ObjectFile.h"
  40 #include "lldb/Target/Process.h"
  41 #include "lldb/Target/Target.h"
  42 #include "lldb/Target/UnixSignals.h"
  43 #include "lldb/Utility/Utils.h"
  44 #include "Utility/ModuleCache.h"
  45
  46 // Define these constants from POSIX mman.h rather than include the file
  47 // so that they will be correct even when compiled on Linux.
  48 #define MAP_PRIVATE 2
  49 #define MAP_ANON 0x1000
  50
  51 using namespace lldb;
  52 using namespace lldb_private;
  53
  54 static uint32_t g_initialize_count = 0;
  55
  56 // Use a singleton function for g_local_platform_sp to avoid init
  57 // constructors since LLDB is often part of a shared library
  58 static PlatformSP&
  59 GetHostPlatformSP ()
  60 {
  61     static PlatformSP g_platform_sp;
  62     return g_platform_sp;
  63 }
  64
  65 const char *
  66 Platform::GetHostPlatformName ()
  67 {
  68     return "host";
  69 }
  70
  71 namespace {
  72
  73     PropertyDefinition
  74     g_properties[] =
  75     {
  76         { "use-module-cache"      , OptionValue::eTypeBoolean , true,  true, nullptr, nullptr, "Use module cache." },
  77         { "module-cache-directory", OptionValue::eTypeFileSpec, true,  0 ,   nullptr, nullptr, "Root directory for cached modules." },
  78         {  nullptr                , OptionValue::eTypeInvalid , false, 0,    nullptr, nullptr, nullptr }
  79     };
  80
  81     enum
  82     {
  83         ePropertyUseModuleCache,
  84         ePropertyModuleCacheDirectory
  85     };
  86
  87 }  // namespace
  88
  89
  90 ConstString
  91 PlatformProperties::GetSettingName ()
  92 {
  93     static ConstString g_setting_name("platform");
  94     return g_setting_name;
  95 }
  96
  97 PlatformProperties::PlatformProperties ()
  98 {
  99     m_collection_sp.reset (new OptionValueProperties (GetSettingName ()));
 100     m_collection_sp->Initialize (g_properties);
 101
 102     auto module_cache_dir = GetModuleCacheDirectory ();
 103     if (module_cache_dir)
 104         return;
 105
 106     llvm::SmallString<64> user_home_dir;
 107     if (!llvm::sys::path::home_directory (user_home_dir))
 108         return;
 109
 110     module_cache_dir = FileSpec (user_home_dir.c_str(), false);
 111     module_cache_dir.AppendPathComponent (".lldb");
 112     module_cache_dir.AppendPathComponent ("module_cache");
 113     SetModuleCacheDirectory (module_cache_dir);
 114 }
 115
 116 bool
 117 PlatformProperties::GetUseModuleCache () const
 118 {
 119     const auto idx = ePropertyUseModuleCache;
 120     return m_collection_sp->GetPropertyAtIndexAsBoolean (
 121         nullptr, idx, g_properties[idx].default_uint_value != 0);
 122 }
 123
 124 bool
 125 PlatformProperties::SetUseModuleCache (bool use_module_cache)
 126 {
 127     return m_collection_sp->SetPropertyAtIndexAsBoolean (nullptr, ePropertyUseModuleCache, use_module_cache);
 128 }
 129
 130 FileSpec
 131 PlatformProperties::GetModuleCacheDirectory () const
 132 {
 133     return m_collection_sp->GetPropertyAtIndexAsFileSpec (nullptr, ePropertyModuleCacheDirectory);
 134 }
 135
 136 bool
 137 PlatformProperties::SetModuleCacheDirectory (const FileSpec& dir_spec)
 138 {
 139     return m_collection_sp->SetPropertyAtIndexAsFileSpec (nullptr, ePropertyModuleCacheDirectory, dir_spec);
 140 }
 141
 142 //------------------------------------------------------------------
 143 /// Get the native host platform plug-in.
 144 ///
 145 /// There should only be one of these for each host that LLDB runs
 146 /// upon that should be statically compiled in and registered using
 147 /// preprocessor macros or other similar build mechanisms.
 148 ///
 149 /// This platform will be used as the default platform when launching
 150 /// or attaching to processes unless another platform is specified.
 151 //------------------------------------------------------------------
 152 PlatformSP
 153 Platform::GetHostPlatform ()
 154 {
 155     return GetHostPlatformSP ();
 156 }
 157
 158 static std::vector<PlatformSP> &
 159 GetPlatformList()
 160 {
 161     static std::vector<PlatformSP> g_platform_list;
 162     return g_platform_list;
 163 }
 164
 165 static std::recursive_mutex &
 166 GetPlatformListMutex()
 167 {
 168     static std::recursive_mutex g_mutex;
 169     return g_mutex;
 170 }
 171
 172 void
 173 Platform::Initialize ()
 174 {
 175     g_initialize_count++;
 176 }
 177
 178 void
 179 Platform::Terminate ()
 180 {
 181     if (g_initialize_count > 0)
 182     {
 183         if (--g_initialize_count == 0)
 184         {
 185             std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 186             GetPlatformList().clear();
 187         }
 188     }
 189 }
 190
 191 const PlatformPropertiesSP &
 192 Platform::GetGlobalPlatformProperties ()
 193 {
 194     static const auto g_settings_sp (std::make_shared<PlatformProperties> ());
 195     return g_settings_sp;
 196 }
 197
 198 void
 199 Platform::SetHostPlatform (const lldb::PlatformSP &platform_sp)
 200 {
 201     // The native platform should use its static void Platform::Initialize()
 202     // function to register itself as the native platform.
 203     GetHostPlatformSP () = platform_sp;
 204
 205     if (platform_sp)
 206     {
 207         std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 208         GetPlatformList().push_back(platform_sp);
 209     }
 210 }
 211
 212 Error
 213 Platform::GetFileWithUUID (const FileSpec &platform_file,
 214                            const UUID *uuid_ptr,
 215                            FileSpec &local_file)
 216 {
 217     // Default to the local case
 218     local_file = platform_file;
 219     return Error();
 220 }
 221
 222 FileSpecList
 223 Platform::LocateExecutableScriptingResources (Target *target, Module &module, Stream* feedback_stream)
 224 {
 225     return FileSpecList();
 226 }
 227
 228 //PlatformSP
 229 //Platform::FindPlugin (Process *process, const ConstString &plugin_name)
 230 //{
 231 //    PlatformCreateInstance create_callback = nullptr;
 232 //    if (plugin_name)
 233 //    {
 234 //        create_callback  = PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name);
 235 //        if (create_callback)
 236 //        {
 237 //            ArchSpec arch;
 238 //            if (process)
 239 //            {
 240 //                arch = process->GetTarget().GetArchitecture();
 241 //            }
 242 //            PlatformSP platform_sp(create_callback(process, &arch));
 243 //            if (platform_sp)
 244 //                return platform_sp;
 245 //        }
 246 //    }
 247 //    else
 248 //    {
 249 //        for (uint32_t idx = 0; (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx)) != nullptr; ++idx)
 250 //        {
 251 //            PlatformSP platform_sp(create_callback(process, nullptr));
 252 //            if (platform_sp)
 253 //                return platform_sp;
 254 //        }
 255 //    }
 256 //    return PlatformSP();
 257 //}
 258
 259 Error
 260 Platform::GetSharedModule (const ModuleSpec &module_spec,
 261                            Process* process,
 262                            ModuleSP &module_sp,
 263                            const FileSpecList *module_search_paths_ptr,
 264                            ModuleSP *old_module_sp_ptr,
 265                            bool *did_create_ptr)
 266 {
 267     if (IsHost ())
 268         return ModuleList::GetSharedModule (module_spec,
 269                                             module_sp,
 270                                             module_search_paths_ptr,
 271                                             old_module_sp_ptr,
 272                                             did_create_ptr,
 273                                             false);
 274
 275     return GetRemoteSharedModule (module_spec,
 276                                   process,
 277                                   module_sp,
 278                                   [&](const ModuleSpec &spec)
 279                                   {
 280                                       Error error = ModuleList::GetSharedModule (
 281                                           spec, module_sp, module_search_paths_ptr, old_module_sp_ptr, did_create_ptr, false);
 282                                       if (error.Success() && module_sp)
 283                                           module_sp->SetPlatformFileSpec(spec.GetFileSpec());
 284                                       return error;
 285                                   },
 286                                   did_create_ptr);
 287 }
 288
 289 bool
 290 Platform::GetModuleSpec (const FileSpec& module_file_spec,
 291                          const ArchSpec& arch,
 292                          ModuleSpec &module_spec)
 293 {
 294     ModuleSpecList module_specs;
 295     if (ObjectFile::GetModuleSpecifications (module_file_spec, 0, 0, module_specs) == 0)
 296         return false;
 297
 298     ModuleSpec matched_module_spec;
 299     return module_specs.FindMatchingModuleSpec (ModuleSpec (module_file_spec, arch),
 300                                                 module_spec);
 301 }
 302
 303 PlatformSP
 304 Platform::Find (const ConstString &name)
 305 {
 306     if (name)
 307     {
 308         static ConstString g_host_platform_name ("host");
 309         if (name == g_host_platform_name)
 310             return GetHostPlatform();
 311
 312         std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 313         for (const auto &platform_sp : GetPlatformList())
 314         {
 315             if (platform_sp->GetName() == name)
 316                 return platform_sp;
 317         }
 318     }
 319     return PlatformSP();
 320 }
 321
 322 PlatformSP
 323 Platform::Create (const ConstString &name, Error &error)
 324 {
 325     PlatformCreateInstance create_callback = nullptr;
 326     lldb::PlatformSP platform_sp;
 327     if (name)
 328     {
 329         static ConstString g_host_platform_name ("host");
 330         if (name == g_host_platform_name)
 331             return GetHostPlatform();
 332
 333         create_callback = PluginManager::GetPlatformCreateCallbackForPluginName (name);
 334         if (create_callback)
 335             platform_sp = create_callback(true, nullptr);
 336         else
 337             error.SetErrorStringWithFormat ("unable to find a plug-in for the platform named \"%s\"", name.GetCString());
 338     }
 339     else
 340         error.SetErrorString ("invalid platform name");
 341
 342     if (platform_sp)
 343     {
 344         std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 345         GetPlatformList().push_back(platform_sp);
 346     }
 347
 348     return platform_sp;
 349 }
 350
 351 PlatformSP
 352 Platform::Create (const ArchSpec &arch, ArchSpec *platform_arch_ptr, Error &error)
 353 {
 354     lldb::PlatformSP platform_sp;
 355     if (arch.IsValid())
 356     {
 357         // Scope for locker
 358         {
 359             // First try exact arch matches across all platforms already created
 360             std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 361             for (const auto &platform_sp : GetPlatformList())
 362             {
 363                 if (platform_sp->IsCompatibleArchitecture(arch, true, platform_arch_ptr))
 364                     return platform_sp;
 365             }
 366
 367             // Next try compatible arch matches across all platforms already created
 368             for (const auto &platform_sp : GetPlatformList())
 369             {
 370                 if (platform_sp->IsCompatibleArchitecture(arch, false, platform_arch_ptr))
 371                     return platform_sp;
 372             }
 373         }
 374
 375         PlatformCreateInstance create_callback;
 376         // First try exact arch matches across all platform plug-ins
 377         uint32_t idx;
 378         for (idx = 0; (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex (idx)); ++idx)
 379         {
 380             if (create_callback)
 381             {
 382                 platform_sp = create_callback(false, &arch);
 383                 if (platform_sp && platform_sp->IsCompatibleArchitecture(arch, true, platform_arch_ptr))
 384                 {
 385                     std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 386                     GetPlatformList().push_back(platform_sp);
 387                     return platform_sp;
 388                 }
 389             }
 390         }
 391         // Next try compatible arch matches across all platform plug-ins
 392         for (idx = 0; (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex (idx)); ++idx)
 393         {
 394             if (create_callback)
 395             {
 396                 platform_sp = create_callback(false, &arch);
 397                 if (platform_sp && platform_sp->IsCompatibleArchitecture(arch, false, platform_arch_ptr))
 398                 {
 399                     std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
 400                     GetPlatformList().push_back(platform_sp);
 401                     return platform_sp;
 402                 }
 403             }
 404         }
 405     }
 406     else
 407         error.SetErrorString ("invalid platform name");
 408     if (platform_arch_ptr)
 409         platform_arch_ptr->Clear();
 410     platform_sp.reset();
 411     return platform_sp;
 412 }
 413
 414 //------------------------------------------------------------------
 415 /// Default Constructor
 416 //------------------------------------------------------------------
 417 Platform::Platform(bool is_host)
 418     : m_is_host(is_host),
 419       m_os_version_set_while_connected(false),
 420       m_system_arch_set_while_connected(false),
 421       m_sdk_sysroot(),
 422       m_sdk_build(),
 423       m_working_dir(),
 424       m_remote_url(),
 425       m_name(),
 426       m_major_os_version(UINT32_MAX),
 427       m_minor_os_version(UINT32_MAX),
 428       m_update_os_version(UINT32_MAX),
 429       m_system_arch(),
 430       m_mutex(),
 431       m_uid_map(),
 432       m_gid_map(),
 433       m_max_uid_name_len(0),
 434       m_max_gid_name_len(0),
 435       m_supports_rsync(false),
 436       m_rsync_opts(),
 437       m_rsync_prefix(),
 438       m_supports_ssh(false),
 439       m_ssh_opts(),
 440       m_ignores_remote_hostname(false),
 441       m_trap_handlers(),
 442       m_calculated_trap_handlers(false),
 443       m_module_cache(llvm::make_unique<ModuleCache>())
 444 {
 445     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
 446     if (log)
 447         log->Printf("%p Platform::Platform()", static_cast<void *>(this));
 448 }
 449
 450 //------------------------------------------------------------------
 451 /// Destructor.
 452 ///
 453 /// The destructor is virtual since this class is designed to be
 454 /// inherited from by the plug-in instance.
 455 //------------------------------------------------------------------
 456 Platform::~Platform()
 457 {
 458     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
 459     if (log)
 460         log->Printf ("%p Platform::~Platform()", static_cast<void*>(this));
 461 }
 462
 463 void
 464 Platform::GetStatus (Stream &strm)
 465 {
 466     uint32_t major = UINT32_MAX;
 467     uint32_t minor = UINT32_MAX;
 468     uint32_t update = UINT32_MAX;
 469     std::string s;
 470     strm.Printf ("  Platform: %s\n", GetPluginName().GetCString());
 471
 472     ArchSpec arch (GetSystemArchitecture());
 473     if (arch.IsValid())
 474     {
 475         if (!arch.GetTriple().str().empty())
 476         {
 477             strm.Printf("    Triple: ");
 478             arch.DumpTriple(strm);
 479             strm.EOL();
 480         }
 481     }
 482
 483     if (GetOSVersion(major, minor, update))
 484     {
 485         strm.Printf("OS Version: %u", major);
 486         if (minor != UINT32_MAX)
 487             strm.Printf(".%u", minor);
 488         if (update != UINT32_MAX)
 489             strm.Printf(".%u", update);
 490
 491         if (GetOSBuildString (s))
 492             strm.Printf(" (%s)", s.c_str());
 493
 494         strm.EOL();
 495     }
 496
 497     if (GetOSKernelDescription (s))
 498         strm.Printf("    Kernel: %s\n", s.c_str());
 499
 500     if (IsHost())
 501     {
 502         strm.Printf("  Hostname: %s\n", GetHostname());
 503     }
 504     else
 505     {
 506         const bool is_connected = IsConnected();
 507         if (is_connected)
 508             strm.Printf("  Hostname: %s\n", GetHostname());
 509         strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
 510     }
 511
 512     if (GetWorkingDirectory())
 513     {
 514         strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
 515     }
 516     if (!IsConnected())
 517         return;
 518
 519     std::string specific_info(GetPlatformSpecificConnectionInformation());
 520
 521     if (!specific_info.empty())
 522         strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
 523 }
 524
 525 bool
 526 Platform::GetOSVersion (uint32_t &major,
 527                         uint32_t &minor,
 528                         uint32_t &update,
 529                         Process *process)
 530 {
 531     std::lock_guard<std::mutex> guard(m_mutex);
 532
 533     bool success = m_major_os_version != UINT32_MAX;
 534     if (IsHost())
 535     {
 536         if (!success)
 537         {
 538             // We have a local host platform
 539             success = HostInfo::GetOSVersion(m_major_os_version, m_minor_os_version, m_update_os_version);
 540             m_os_version_set_while_connected = success;
 541         }
 542     }
 543     else
 544     {
 545         // We have a remote platform. We can only fetch the remote
 546         // OS version if we are connected, and we don't want to do it
 547         // more than once.
 548
 549         const bool is_connected = IsConnected();
 550
 551         bool fetch = false;
 552         if (success)
 553         {
 554             // We have valid OS version info, check to make sure it wasn't
 555             // manually set prior to connecting. If it was manually set prior
 556             // to connecting, then lets fetch the actual OS version info
 557             // if we are now connected.
 558             if (is_connected && !m_os_version_set_while_connected)
 559                 fetch = true;
 560         }
 561         else
 562         {
 563             // We don't have valid OS version info, fetch it if we are connected
 564             fetch = is_connected;
 565         }
 566
 567         if (fetch)
 568         {
 569             success = GetRemoteOSVersion ();
 570             m_os_version_set_while_connected = success;
 571         }
 572     }
 573
 574     if (success)
 575     {
 576         major = m_major_os_version;
 577         minor = m_minor_os_version;
 578         update = m_update_os_version;
 579     }
 580     else if (process)
 581     {
 582         // Check with the process in case it can answer the question if
 583         // a process was provided
 584         return process->GetHostOSVersion(major, minor, update);
 585     }
 586     return success;
 587 }
 588
 589 bool
 590 Platform::GetOSBuildString (std::string &s)
 591 {
 592     s.clear();
 593
 594     if (IsHost())
 595 #if !defined(__linux__)
 596         return HostInfo::GetOSBuildString(s);
 597 #else
 598         return false;
 599 #endif
 600     else
 601         return GetRemoteOSBuildString (s);
 602 }
 603
 604 bool
 605 Platform::GetOSKernelDescription (std::string &s)
 606 {
 607     if (IsHost())
 608 #if !defined(__linux__)
 609         return HostInfo::GetOSKernelDescription(s);
 610 #else
 611         return false;
 612 #endif
 613     else
 614         return GetRemoteOSKernelDescription (s);
 615 }
 616
 617 void
 618 Platform::AddClangModuleCompilationOptions (Target *target, std::vector<std::string> &options)
 619 {
 620     std::vector<std::string> default_compilation_options =
 621     {
 622         "-x", "c++", "-Xclang", "-nostdsysteminc", "-Xclang", "-nostdsysteminc"
 623     };
 624
 625     options.insert(options.end(),
 626                    default_compilation_options.begin(),
 627                    default_compilation_options.end());
 628 }
 629
 630 FileSpec
 631 Platform::GetWorkingDirectory ()
 632 {
 633     if (IsHost())
 634     {
 635         char cwd[PATH_MAX];
 636         if (getcwd(cwd, sizeof(cwd)))
 637             return FileSpec{cwd, true};
 638         else
 639             return FileSpec{};
 640     }
 641     else
 642     {
 643         if (!m_working_dir)
 644             m_working_dir = GetRemoteWorkingDirectory();
 645         return m_working_dir;
 646     }
 647 }
 648
 649 struct RecurseCopyBaton
 650 {
 651     const FileSpec& dst;
 652     Platform *platform_ptr;
 653     Error error;
 654 };
 655
 656 static FileSpec::EnumerateDirectoryResult
 657 RecurseCopy_Callback (void *baton,
 658                       FileSpec::FileType file_type,
 659                       const FileSpec &src)
 660 {
 661     RecurseCopyBaton* rc_baton = (RecurseCopyBaton*)baton;
 662     switch (file_type)
 663     {
 664         case FileSpec::eFileTypePipe:
 665         case FileSpec::eFileTypeSocket:
 666             // we have no way to copy pipes and sockets - ignore them and continue
 667             return FileSpec::eEnumerateDirectoryResultNext;
 668             break;
 669
 670         case FileSpec::eFileTypeDirectory:
 671             {
 672                 // make the new directory and get in there
 673                 FileSpec dst_dir = rc_baton->dst;
 674                 if (!dst_dir.GetFilename())
 675                     dst_dir.GetFilename() = src.GetLastPathComponent();
 676                 Error error = rc_baton->platform_ptr->MakeDirectory(dst_dir, lldb::eFilePermissionsDirectoryDefault);
 677                 if (error.Fail())
 678                 {
 679                     rc_baton->error.SetErrorStringWithFormat("unable to setup directory %s on remote end",
 680                             dst_dir.GetCString());
 681                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 682                 }
 683
 684                 // now recurse
 685                 std::string src_dir_path (src.GetPath());
 686
 687                 // Make a filespec that only fills in the directory of a FileSpec so
 688                 // when we enumerate we can quickly fill in the filename for dst copies
 689                 FileSpec recurse_dst;
 690                 recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
 691                 RecurseCopyBaton rc_baton2 = { recurse_dst, rc_baton->platform_ptr, Error() };
 692                 FileSpec::EnumerateDirectory(src_dir_path.c_str(), true, true, true, RecurseCopy_Callback, &rc_baton2);
 693                 if (rc_baton2.error.Fail())
 694                 {
 695                     rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
 696                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 697                 }
 698                 return FileSpec::eEnumerateDirectoryResultNext;
 699             }
 700             break;
 701
 702         case FileSpec::eFileTypeSymbolicLink:
 703             {
 704                 // copy the file and keep going
 705                 FileSpec dst_file = rc_baton->dst;
 706                 if (!dst_file.GetFilename())
 707                     dst_file.GetFilename() = src.GetFilename();
 708
 709                 FileSpec src_resolved;
 710
 711                 rc_baton->error = FileSystem::Readlink(src, src_resolved);
 712
 713                 if (rc_baton->error.Fail())
 714                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 715
 716                 rc_baton->error = rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);
 717
 718                 if (rc_baton->error.Fail())
 719                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 720
 721                 return FileSpec::eEnumerateDirectoryResultNext;
 722             }
 723             break;
 724
 725         case FileSpec::eFileTypeRegular:
 726             {
 727                 // copy the file and keep going
 728                 FileSpec dst_file = rc_baton->dst;
 729                 if (!dst_file.GetFilename())
 730                     dst_file.GetFilename() = src.GetFilename();
 731                 Error err = rc_baton->platform_ptr->PutFile(src, dst_file);
 732                 if (err.Fail())
 733                 {
 734                     rc_baton->error.SetErrorString(err.AsCString());
 735                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 736                 }
 737                 return FileSpec::eEnumerateDirectoryResultNext;
 738             }
 739             break;
 740
 741         case FileSpec::eFileTypeInvalid:
 742         case FileSpec::eFileTypeOther:
 743         case FileSpec::eFileTypeUnknown:
 744             rc_baton->error.SetErrorStringWithFormat("invalid file detected during copy: %s", src.GetPath().c_str());
 745             return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 746             break;
 747     }
 748     llvm_unreachable("Unhandled FileSpec::FileType!");
 749 }
 750
 751 Error
 752 Platform::Install (const FileSpec& src, const FileSpec& dst)
 753 {
 754     Error error;
 755
 756     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 757     if (log)
 758         log->Printf ("Platform::Install (src='%s', dst='%s')", src.GetPath().c_str(), dst.GetPath().c_str());
 759     FileSpec fixed_dst(dst);
 760
 761     if (!fixed_dst.GetFilename())
 762         fixed_dst.GetFilename() = src.GetFilename();
 763
 764     FileSpec working_dir = GetWorkingDirectory();
 765
 766     if (dst)
 767     {
 768         if (dst.GetDirectory())
 769         {
 770             const char first_dst_dir_char = dst.GetDirectory().GetCString()[0];
 771             if (first_dst_dir_char == '/' || first_dst_dir_char  == '\\')
 772             {
 773                 fixed_dst.GetDirectory() = dst.GetDirectory();
 774             }
 775             // If the fixed destination file doesn't have a directory yet,
 776             // then we must have a relative path. We will resolve this relative
 777             // path against the platform's working directory
 778             if (!fixed_dst.GetDirectory())
 779             {
 780                 FileSpec relative_spec;
 781                 std::string path;
 782                 if (working_dir)
 783                 {
 784                     relative_spec = working_dir;
 785                     relative_spec.AppendPathComponent(dst.GetPath());
 786                     fixed_dst.GetDirectory() = relative_spec.GetDirectory();
 787                 }
 788                 else
 789                 {
 790                     error.SetErrorStringWithFormat("platform working directory must be valid for relative path '%s'", dst.GetPath().c_str());
 791                     return error;
 792                 }
 793             }
 794         }
 795         else
 796         {
 797             if (working_dir)
 798             {
 799                 fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
 800             }
 801             else
 802             {
 803                 error.SetErrorStringWithFormat("platform working directory must be valid for relative path '%s'", dst.GetPath().c_str());
 804                 return error;
 805             }
 806         }
 807     }
 808     else
 809     {
 810         if (working_dir)
 811         {
 812             fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
 813         }
 814         else
 815         {
 816             error.SetErrorStringWithFormat("platform working directory must be valid when destination directory is empty");
 817             return error;
 818         }
 819     }
 820
 821     if (log)
 822         log->Printf ("Platform::Install (src='%s', dst='%s') fixed_dst='%s'", src.GetPath().c_str(), dst.GetPath().c_str(), fixed_dst.GetPath().c_str());
 823
 824     if (GetSupportsRSync())
 825     {
 826         error = PutFile(src, dst);
 827     }
 828     else
 829     {
 830         switch (src.GetFileType())
 831         {
 832             case FileSpec::eFileTypeDirectory:
 833                 {
 834                     if (GetFileExists (fixed_dst))
 835                         Unlink(fixed_dst);
 836                     uint32_t permissions = src.GetPermissions();
 837                     if (permissions == 0)
 838                         permissions = eFilePermissionsDirectoryDefault;
 839                     error = MakeDirectory(fixed_dst, permissions);
 840                     if (error.Success())
 841                     {
 842                         // Make a filespec that only fills in the directory of a FileSpec so
 843                         // when we enumerate we can quickly fill in the filename for dst copies
 844                         FileSpec recurse_dst;
 845                         recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
 846                         std::string src_dir_path (src.GetPath());
 847                         RecurseCopyBaton baton = { recurse_dst, this, Error() };
 848                         FileSpec::EnumerateDirectory(src_dir_path.c_str(), true, true, true, RecurseCopy_Callback, &baton);
 849                         return baton.error;
 850                     }
 851                 }
 852                 break;
 853
 854             case FileSpec::eFileTypeRegular:
 855                 if (GetFileExists (fixed_dst))
 856                     Unlink(fixed_dst);
 857                 error = PutFile(src, fixed_dst);
 858                 break;
 859
 860             case FileSpec::eFileTypeSymbolicLink:
 861                 {
 862                     if (GetFileExists (fixed_dst))
 863                         Unlink(fixed_dst);
 864                     FileSpec src_resolved;
 865                     error = FileSystem::Readlink(src, src_resolved);
 866                     if (error.Success())
 867                         error = CreateSymlink(dst, src_resolved);
 868                 }
 869                 break;
 870             case FileSpec::eFileTypePipe:
 871                 error.SetErrorString("platform install doesn't handle pipes");
 872                 break;
 873             case FileSpec::eFileTypeSocket:
 874                 error.SetErrorString("platform install doesn't handle sockets");
 875                 break;
 876             case FileSpec::eFileTypeInvalid:
 877             case FileSpec::eFileTypeUnknown:
 878             case FileSpec::eFileTypeOther:
 879                 error.SetErrorString("platform install doesn't handle non file or directory items");
 880                 break;
 881         }
 882     }
 883     return error;
 884 }
 885
 886 bool
 887 Platform::SetWorkingDirectory(const FileSpec &file_spec)
 888 {
 889     if (IsHost())
 890     {
 891         Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 892         if (log)
 893             log->Printf("Platform::SetWorkingDirectory('%s')",
 894                     file_spec.GetCString());
 895         if (file_spec)
 896         {
 897             if (::chdir(file_spec.GetCString()) == 0)
 898                 return true;
 899         }
 900         return false;
 901     }
 902     else
 903     {
 904         m_working_dir.Clear();
 905         return SetRemoteWorkingDirectory(file_spec);
 906     }
 907 }
 908
 909 Error
 910 Platform::MakeDirectory(const FileSpec &file_spec, uint32_t permissions)
 911 {
 912     if (IsHost())
 913         return FileSystem::MakeDirectory(file_spec, permissions);
 914     else
 915     {
 916         Error error;
 917         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
 918         return error;
 919     }
 920 }
 921
 922 Error
 923 Platform::GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions)
 924 {
 925     if (IsHost())
 926         return FileSystem::GetFilePermissions(file_spec, file_permissions);
 927     else
 928     {
 929         Error error;
 930         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
 931         return error;
 932     }
 933 }
 934
 935 Error
 936 Platform::SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions)
 937 {
 938     if (IsHost())
 939         return FileSystem::SetFilePermissions(file_spec, file_permissions);
 940     else
 941     {
 942         Error error;
 943         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
 944         return error;
 945     }
 946 }
 947
 948 ConstString
 949 Platform::GetName ()
 950 {
 951     return GetPluginName();
 952 }
 953
 954 const char *
 955 Platform::GetHostname ()
 956 {
 957     if (IsHost())
 958         return "127.0.0.1";
 959
 960     if (m_name.empty())
 961         return nullptr;
 962     return m_name.c_str();
 963 }
 964
 965 ConstString
 966 Platform::GetFullNameForDylib (ConstString basename)
 967 {
 968     return basename;
 969 }
 970
 971 bool
 972 Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir)
 973 {
 974     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 975     if (log)
 976         log->Printf("Platform::SetRemoteWorkingDirectory('%s')",
 977                 working_dir.GetCString());
 978     m_working_dir = working_dir;
 979     return true;
 980 }
 981
 982 const char *
 983 Platform::GetUserName (uint32_t uid)
 984 {
 985 #if !defined(LLDB_DISABLE_POSIX)
 986     const char *user_name = GetCachedUserName(uid);
 987     if (user_name)
 988         return user_name;
 989     if (IsHost())
 990     {
 991         std::string name;
 992         if (HostInfo::LookupUserName(uid, name))
 993             return SetCachedUserName (uid, name.c_str(), name.size());
 994     }
 995 #endif
 996     return nullptr;
 997 }
 998
 999 const char *
1000 Platform::GetGroupName (uint32_t gid)
1001 {
1002 #if !defined(LLDB_DISABLE_POSIX)
1003     const char *group_name = GetCachedGroupName(gid);
1004     if (group_name)
1005         return group_name;
1006     if (IsHost())
1007     {
1008         std::string name;
1009         if (HostInfo::LookupGroupName(gid, name))
1010             return SetCachedGroupName (gid, name.c_str(), name.size());
1011     }
1012 #endif
1013     return nullptr;
1014 }
1015
1016 bool
1017 Platform::SetOSVersion (uint32_t major,
1018                         uint32_t minor,
1019                         uint32_t update)
1020 {
1021     if (IsHost())
1022     {
1023         // We don't need anyone setting the OS version for the host platform,
1024         // we should be able to figure it out by calling HostInfo::GetOSVersion(...).
1025         return false;
1026     }
1027     else
1028     {
1029         // We have a remote platform, allow setting the target OS version if
1030         // we aren't connected, since if we are connected, we should be able to
1031         // request the remote OS version from the connected platform.
1032         if (IsConnected())
1033             return false;
1034         else
1035         {
1036             // We aren't connected and we might want to set the OS version
1037             // ahead of time before we connect so we can peruse files and
1038             // use a local SDK or PDK cache of support files to disassemble
1039             // or do other things.
1040             m_major_os_version = major;
1041             m_minor_os_version = minor;
1042             m_update_os_version = update;
1043             return true;
1044         }
1045     }
1046     return false;
1047 }
1048
1049 Error
1050 Platform::ResolveExecutable (const ModuleSpec &module_spec,
1051                              lldb::ModuleSP &exe_module_sp,
1052                              const FileSpecList *module_search_paths_ptr)
1053 {
1054     Error error;
1055     if (module_spec.GetFileSpec().Exists())
1056     {
1057         if (module_spec.GetArchitecture().IsValid())
1058         {
1059             error = ModuleList::GetSharedModule(module_spec,
1060                                                 exe_module_sp,
1061                                                 module_search_paths_ptr,
1062                                                 nullptr,
1063                                                 nullptr);
1064         }
1065         else
1066         {
1067             // No valid architecture was specified, ask the platform for
1068             // the architectures that we should be using (in the correct order)
1069             // and see if we can find a match that way
1070             ModuleSpec arch_module_spec(module_spec);
1071             for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, arch_module_spec.GetArchitecture()); ++idx)
1072             {
1073                 error = ModuleList::GetSharedModule(arch_module_spec,
1074                                                     exe_module_sp,
1075                                                     module_search_paths_ptr,
1076                                                     nullptr,
1077                                                     nullptr);
1078                 // Did we find an executable using one of the
1079                 if (error.Success() && exe_module_sp)
1080                     break;
1081             }
1082         }
1083     }
1084     else
1085     {
1086         error.SetErrorStringWithFormat ("'%s' does not exist",
1087                                         module_spec.GetFileSpec().GetPath().c_str());
1088     }
1089     return error;
1090 }
1091
1092 Error
1093 Platform::ResolveSymbolFile (Target &target,
1094                              const ModuleSpec &sym_spec,
1095                              FileSpec &sym_file)
1096 {
1097     Error error;
1098     if (sym_spec.GetSymbolFileSpec().Exists())
1099         sym_file = sym_spec.GetSymbolFileSpec();
1100     else
1101         error.SetErrorString("unable to resolve symbol file");
1102     return error;
1103 }
1104
1105 bool
1106 Platform::ResolveRemotePath (const FileSpec &platform_path,
1107                              FileSpec &resolved_platform_path)
1108 {
1109     resolved_platform_path = platform_path;
1110     return resolved_platform_path.ResolvePath();
1111 }
1112
1113 const ArchSpec &
1114 Platform::GetSystemArchitecture()
1115 {
1116     if (IsHost())
1117     {
1118         if (!m_system_arch.IsValid())
1119         {
1120             // We have a local host platform
1121             m_system_arch = HostInfo::GetArchitecture();
1122             m_system_arch_set_while_connected = m_system_arch.IsValid();
1123         }
1124     }
1125     else
1126     {
1127         // We have a remote platform. We can only fetch the remote
1128         // system architecture if we are connected, and we don't want to do it
1129         // more than once.
1130
1131         const bool is_connected = IsConnected();
1132
1133         bool fetch = false;
1134         if (m_system_arch.IsValid())
1135         {
1136             // We have valid OS version info, check to make sure it wasn't
1137             // manually set prior to connecting. If it was manually set prior
1138             // to connecting, then lets fetch the actual OS version info
1139             // if we are now connected.
1140             if (is_connected && !m_system_arch_set_while_connected)
1141                 fetch = true;
1142         }
1143         else
1144         {
1145             // We don't have valid OS version info, fetch it if we are connected
1146             fetch = is_connected;
1147         }
1148
1149         if (fetch)
1150         {
1151             m_system_arch = GetRemoteSystemArchitecture ();
1152             m_system_arch_set_while_connected = m_system_arch.IsValid();
1153         }
1154     }
1155     return m_system_arch;
1156 }
1157
1158 Error
1159 Platform::ConnectRemote (Args& args)
1160 {
1161     Error error;
1162     if (IsHost())
1163         error.SetErrorStringWithFormat ("The currently selected platform (%s) is the host platform and is always connected.", GetPluginName().GetCString());
1164     else
1165         error.SetErrorStringWithFormat ("Platform::ConnectRemote() is not supported by %s", GetPluginName().GetCString());
1166     return error;
1167 }
1168
1169 Error
1170 Platform::DisconnectRemote ()
1171 {
1172     Error error;
1173     if (IsHost())
1174         error.SetErrorStringWithFormat ("The currently selected platform (%s) is the host platform and is always connected.", GetPluginName().GetCString());
1175     else
1176         error.SetErrorStringWithFormat ("Platform::DisconnectRemote() is not supported by %s", GetPluginName().GetCString());
1177     return error;
1178 }
1179
1180 bool
1181 Platform::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
1182 {
1183     // Take care of the host case so that each subclass can just
1184     // call this function to get the host functionality.
1185     if (IsHost())
1186         return Host::GetProcessInfo (pid, process_info);
1187     return false;
1188 }
1189
1190 uint32_t
1191 Platform::FindProcesses (const ProcessInstanceInfoMatch &match_info,
1192                          ProcessInstanceInfoList &process_infos)
1193 {
1194     // Take care of the host case so that each subclass can just
1195     // call this function to get the host functionality.
1196     uint32_t match_count = 0;
1197     if (IsHost())
1198         match_count = Host::FindProcesses (match_info, process_infos);
1199     return match_count;
1200 }
1201
1202 Error
1203 Platform::LaunchProcess (ProcessLaunchInfo &launch_info)
1204 {
1205     Error error;
1206     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
1207     if (log)
1208         log->Printf ("Platform::%s()", __FUNCTION__);
1209
1210     // Take care of the host case so that each subclass can just
1211     // call this function to get the host functionality.
1212     if (IsHost())
1213     {
1214         if (::getenv ("LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY"))
1215             launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY);
1216
1217         if (launch_info.GetFlags().Test (eLaunchFlagLaunchInShell))
1218         {
1219             const bool is_localhost = true;
1220             const bool will_debug = launch_info.GetFlags().Test(eLaunchFlagDebug);
1221             const bool first_arg_is_full_shell_command = false;
1222             uint32_t num_resumes = GetResumeCountForLaunchInfo (launch_info);
1223             if (log)
1224             {
1225                 const FileSpec &shell = launch_info.GetShell();
1226                 const char *shell_str = (shell) ? shell.GetPath().c_str() : "<null>";
1227                 log->Printf ("Platform::%s GetResumeCountForLaunchInfo() returned %" PRIu32 ", shell is '%s'",
1228                              __FUNCTION__,
1229                              num_resumes,
1230                              shell_str);
1231             }
1232
1233             if (!launch_info.ConvertArgumentsForLaunchingInShell (error,
1234                                                                   is_localhost,
1235                                                                   will_debug,
1236                                                                   first_arg_is_full_shell_command,
1237                                                                   num_resumes))
1238                 return error;
1239         }
1240         else if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments))
1241         {
1242             error = ShellExpandArguments(launch_info);
1243             if (error.Fail())
1244             {
1245                 error.SetErrorStringWithFormat("shell expansion failed (reason: %s). consider launching with 'process launch'.",
1246                                                error.AsCString("unknown"));
1247                 return error;
1248             }
1249         }
1250
1251         if (log)
1252             log->Printf ("Platform::%s final launch_info resume count: %" PRIu32, __FUNCTION__, launch_info.GetResumeCount ());
1253
1254         error = Host::LaunchProcess (launch_info);
1255     }
1256     else
1257         error.SetErrorString ("base lldb_private::Platform class can't launch remote processes");
1258     return error;
1259 }
1260
1261 Error
1262 Platform::ShellExpandArguments (ProcessLaunchInfo &launch_info)
1263 {
1264     if (IsHost())
1265         return Host::ShellExpandArguments(launch_info);
1266     return Error("base lldb_private::Platform class can't expand arguments");
1267 }
1268
1269 Error
1270 Platform::KillProcess (const lldb::pid_t pid)
1271 {
1272     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
1273     if (log)
1274         log->Printf ("Platform::%s, pid %" PRIu64, __FUNCTION__, pid);
1275
1276     // Try to find a process plugin to handle this Kill request.  If we can't, fall back to
1277     // the default OS implementation.
1278     size_t num_debuggers = Debugger::GetNumDebuggers();
1279     for (size_t didx = 0; didx < num_debuggers; ++didx)
1280     {
1281         DebuggerSP debugger = Debugger::GetDebuggerAtIndex(didx);
1282         lldb_private::TargetList &targets = debugger->GetTargetList();
1283         for (int tidx = 0; tidx < targets.GetNumTargets(); ++tidx)
1284         {
1285             ProcessSP process = targets.GetTargetAtIndex(tidx)->GetProcessSP();
1286             if (process->GetID() == pid)
1287                 return process->Destroy(true);
1288         }
1289     }
1290
1291     if (!IsHost())
1292     {
1293         return Error("base lldb_private::Platform class can't kill remote processes unless "
1294                      "they are controlled by a process plugin");
1295     }
1296     Host::Kill(pid, SIGTERM);
1297     return Error();
1298 }
1299
1300 lldb::ProcessSP
1301 Platform::DebugProcess (ProcessLaunchInfo &launch_info,
1302                         Debugger &debugger,
1303                         Target *target,       // Can be nullptr, if nullptr create a new target, else use existing one
1304                         Error &error)
1305 {
1306     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
1307     if (log)
1308         log->Printf ("Platform::%s entered (target %p)", __FUNCTION__, static_cast<void*>(target));
1309
1310     ProcessSP process_sp;
1311     // Make sure we stop at the entry point
1312     launch_info.GetFlags ().Set (eLaunchFlagDebug);
1313     // We always launch the process we are going to debug in a separate process
1314     // group, since then we can handle ^C interrupts ourselves w/o having to worry
1315     // about the target getting them as well.
1316     launch_info.SetLaunchInSeparateProcessGroup(true);
1317
1318     error = LaunchProcess (launch_info);
1319     if (error.Success())
1320     {
1321         if (log)
1322             log->Printf ("Platform::%s LaunchProcess() call succeeded (pid=%" PRIu64 ")", __FUNCTION__, launch_info.GetProcessID ());
1323         if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
1324         {
1325             ProcessAttachInfo attach_info (launch_info);
1326             process_sp = Attach (attach_info, debugger, target, error);
1327             if (process_sp)
1328             {
1329                 if (log)
1330                     log->Printf ("Platform::%s Attach() succeeded, Process plugin: %s", __FUNCTION__, process_sp->GetPluginName ().AsCString ());
1331                 launch_info.SetHijackListener(attach_info.GetHijackListener());
1332
1333                 // Since we attached to the process, it will think it needs to detach
1334                 // if the process object just goes away without an explicit call to
1335                 // Process::Kill() or Process::Detach(), so let it know to kill the
1336                 // process if this happens.
1337                 process_sp->SetShouldDetach (false);
1338
1339                 // If we didn't have any file actions, the pseudo terminal might
1340                 // have been used where the slave side was given as the file to
1341                 // open for stdin/out/err after we have already opened the master
1342                 // so we can read/write stdin/out/err.
1343                 int pty_fd = launch_info.GetPTY().ReleaseMasterFileDescriptor();
1344                 if (pty_fd != lldb_utility::PseudoTerminal::invalid_fd)
1345                 {
1346                     process_sp->SetSTDIOFileDescriptor(pty_fd);
1347                 }
1348             }
1349             else
1350             {
1351                 if (log)
1352                     log->Printf ("Platform::%s Attach() failed: %s", __FUNCTION__, error.AsCString ());
1353             }
1354         }
1355         else
1356         {
1357             if (log)
1358                 log->Printf ("Platform::%s LaunchProcess() returned launch_info with invalid process id", __FUNCTION__);
1359         }
1360     }
1361     else
1362     {
1363         if (log)
1364             log->Printf ("Platform::%s LaunchProcess() failed: %s", __FUNCTION__, error.AsCString ());
1365     }
1366
1367     return process_sp;
1368 }
1369
1370 lldb::PlatformSP
1371 Platform::GetPlatformForArchitecture (const ArchSpec &arch, ArchSpec *platform_arch_ptr)
1372 {
1373     lldb::PlatformSP platform_sp;
1374     Error error;
1375     if (arch.IsValid())
1376         platform_sp = Platform::Create (arch, platform_arch_ptr, error);
1377     return platform_sp;
1378 }
1379
1380 //------------------------------------------------------------------
1381 /// Lets a platform answer if it is compatible with a given
1382 /// architecture and the target triple contained within.
1383 //------------------------------------------------------------------
1384 bool
1385 Platform::IsCompatibleArchitecture (const ArchSpec &arch, bool exact_arch_match, ArchSpec *compatible_arch_ptr)
1386 {
1387     // If the architecture is invalid, we must answer true...
1388     if (arch.IsValid())
1389     {
1390         ArchSpec platform_arch;
1391         // Try for an exact architecture match first.
1392         if (exact_arch_match)
1393         {
1394             for (uint32_t arch_idx=0; GetSupportedArchitectureAtIndex (arch_idx, platform_arch); ++arch_idx)
1395             {
1396                 if (arch.IsExactMatch(platform_arch))
1397                 {
1398                     if (compatible_arch_ptr)
1399                         *compatible_arch_ptr = platform_arch;
1400                     return true;
1401                 }
1402             }
1403         }
1404         else
1405         {
1406             for (uint32_t arch_idx=0; GetSupportedArchitectureAtIndex (arch_idx, platform_arch); ++arch_idx)
1407             {
1408                 if (arch.IsCompatibleMatch(platform_arch))
1409                 {
1410                     if (compatible_arch_ptr)
1411                         *compatible_arch_ptr = platform_arch;
1412                     return true;
1413                 }
1414             }
1415         }
1416     }
1417     if (compatible_arch_ptr)
1418         compatible_arch_ptr->Clear();
1419     return false;
1420 }
1421
1422 Error
1423 Platform::PutFile (const FileSpec& source,
1424                    const FileSpec& destination,
1425                    uint32_t uid,
1426                    uint32_t gid)
1427 {
1428     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
1429     if (log)
1430         log->Printf("[PutFile] Using block by block transfer....\n");
1431
1432     uint32_t source_open_options = File::eOpenOptionRead | File::eOpenOptionCloseOnExec;
1433     if (source.GetFileType() == FileSpec::eFileTypeSymbolicLink)
1434         source_open_options |= File::eOpenOptionDontFollowSymlinks;
1435
1436     File source_file(source, source_open_options, lldb::eFilePermissionsUserRW);
1437     Error error;
1438     uint32_t permissions = source_file.GetPermissions(error);
1439     if (permissions == 0)
1440         permissions = lldb::eFilePermissionsFileDefault;
1441
1442     if (!source_file.IsValid())
1443         return Error("PutFile: unable to open source file");
1444     lldb::user_id_t dest_file = OpenFile (destination,
1445                                           File::eOpenOptionCanCreate |
1446                                           File::eOpenOptionWrite |
1447                                           File::eOpenOptionTruncate |
1448                                           File::eOpenOptionCloseOnExec,
1449                                           permissions,
1450                                           error);
1451     if (log)
1452         log->Printf ("dest_file = %" PRIu64 "\n", dest_file);
1453
1454     if (error.Fail())
1455         return error;
1456     if (dest_file == UINT64_MAX)
1457         return Error("unable to open target file");
1458     lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
1459     uint64_t offset = 0;
1460     for (;;)
1461     {
1462         size_t bytes_read = buffer_sp->GetByteSize();
1463         error = source_file.Read(buffer_sp->GetBytes(), bytes_read);
1464         if (error.Fail() || bytes_read == 0)
1465             break;
1466
1467         const uint64_t bytes_written = WriteFile(dest_file, offset,
1468             buffer_sp->GetBytes(), bytes_read, error);
1469         if (error.Fail())
1470             break;
1471
1472         offset += bytes_written;
1473         if (bytes_written != bytes_read)
1474         {
1475             // We didn't write the correct number of bytes, so adjust
1476             // the file position in the source file we are reading from...
1477             source_file.SeekFromStart(offset);
1478         }
1479     }
1480     CloseFile(dest_file, error);
1481
1482     if (uid == UINT32_MAX && gid == UINT32_MAX)
1483         return error;
1484
1485     // TODO: ChownFile?
1486
1487     return error;
1488 }
1489
1490 Error
1491 Platform::GetFile(const FileSpec &source,
1492                   const FileSpec &destination)
1493 {
1494     Error error("unimplemented");
1495     return error;
1496 }
1497
1498 Error
1499 Platform::CreateSymlink(const FileSpec &src, // The name of the link is in src
1500                         const FileSpec &dst) // The symlink points to dst
1501 {
1502     Error error("unimplemented");
1503     return error;
1504 }
1505
1506 bool
1507 Platform::GetFileExists(const lldb_private::FileSpec &file_spec)
1508 {
1509     return false;
1510 }
1511
1512 Error
1513 Platform::Unlink(const FileSpec &path)
1514 {
1515     Error error("unimplemented");
1516     return error;
1517 }
1518
1519 uint64_t
1520 Platform::ConvertMmapFlagsToPlatform(const ArchSpec &arch, unsigned flags)
1521 {
1522     uint64_t flags_platform = 0;
1523     if (flags & eMmapFlagsPrivate)
1524         flags_platform |= MAP_PRIVATE;
1525     if (flags & eMmapFlagsAnon)
1526         flags_platform |= MAP_ANON;
1527     return flags_platform;
1528 }
1529
1530 lldb_private::Error
1531 Platform::RunShellCommand(const char *command,           // Shouldn't be nullptr
1532                           const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
1533                           int *status_ptr,               // Pass nullptr if you don't want the process exit status
1534                           int *signo_ptr,                // Pass nullptr if you don't want the signal that caused the process to exit
1535                           std::string *command_output,   // Pass nullptr if you don't want the command output
1536                           uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
1537 {
1538     if (IsHost())
1539         return Host::RunShellCommand (command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
1540     else
1541         return Error("unimplemented");
1542 }
1543
1544 bool
1545 Platform::CalculateMD5 (const FileSpec& file_spec,
1546                         uint64_t &low,
1547                         uint64_t &high)
1548 {
1549     if (IsHost())
1550         return FileSystem::CalculateMD5(file_spec, low, high);
1551     else
1552         return false;
1553 }
1554
1555 void
1556 Platform::SetLocalCacheDirectory (const char* local)
1557 {
1558     m_local_cache_directory.assign(local);
1559 }
1560
1561 const char*
1562 Platform::GetLocalCacheDirectory ()
1563 {
1564     return m_local_cache_directory.c_str();
1565 }
1566
1567 static OptionDefinition
1568 g_rsync_option_table[] =
1569 {
1570     {   LLDB_OPT_SET_ALL, false, "rsync"                  , 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone         , "Enable rsync." },
1571     {   LLDB_OPT_SET_ALL, false, "rsync-opts"             , 'R', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCommandName  , "Platform-specific options required for rsync to work." },
1572     {   LLDB_OPT_SET_ALL, false, "rsync-prefix"           , 'P', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCommandName  , "Platform-specific rsync prefix put before the remote path." },
1573     {   LLDB_OPT_SET_ALL, false, "ignore-remote-hostname" , 'i', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone         , "Do not automatically fill in the remote hostname when composing the rsync command." },
1574 };
1575
1576 static OptionDefinition
1577 g_ssh_option_table[] =
1578 {
1579     {   LLDB_OPT_SET_ALL, false, "ssh"                    , 's', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone         , "Enable SSH." },
1580     {   LLDB_OPT_SET_ALL, false, "ssh-opts"               , 'S', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCommandName  , "Platform-specific options required for SSH to work." },
1581 };
1582
1583 static OptionDefinition
1584 g_caching_option_table[] =
1585 {
1586     {   LLDB_OPT_SET_ALL, false, "local-cache-dir"        , 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePath         , "Path in which to store local copies of files." },
1587 };
1588
1589 const lldb_private::OptionDefinition*
1590 OptionGroupPlatformRSync::GetDefinitions ()
1591 {
1592     return g_rsync_option_table;
1593 }
1594
1595 void
1596 OptionGroupPlatformRSync::OptionParsingStarting (CommandInterpreter &interpreter)
1597 {
1598     m_rsync = false;
1599     m_rsync_opts.clear();
1600     m_rsync_prefix.clear();
1601     m_ignores_remote_hostname = false;
1602 }
1603
1604 lldb_private::Error
1605 OptionGroupPlatformRSync::SetOptionValue (CommandInterpreter &interpreter,
1606                 uint32_t option_idx,
1607                 const char *option_arg)
1608 {
1609     Error error;
1610     char short_option = (char) GetDefinitions()[option_idx].short_option;
1611     switch (short_option)
1612     {
1613         case 'r':
1614             m_rsync = true;
1615             break;
1616
1617         case 'R':
1618             m_rsync_opts.assign(option_arg);
1619             break;
1620
1621         case 'P':
1622             m_rsync_prefix.assign(option_arg);
1623             break;
1624
1625         case 'i':
1626             m_ignores_remote_hostname = true;
1627             break;
1628
1629         default:
1630             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1631             break;
1632     }
1633
1634     return error;
1635 }
1636
1637 uint32_t
1638 OptionGroupPlatformRSync::GetNumDefinitions ()
1639 {
1640     return llvm::array_lengthof(g_rsync_option_table);
1641 }
1642
1643 lldb::BreakpointSP
1644 Platform::SetThreadCreationBreakpoint (lldb_private::Target &target)
1645 {
1646     return lldb::BreakpointSP();
1647 }
1648
1649 const lldb_private::OptionDefinition*
1650 OptionGroupPlatformSSH::GetDefinitions ()
1651 {
1652     return g_ssh_option_table;
1653 }
1654
1655 void
1656 OptionGroupPlatformSSH::OptionParsingStarting (CommandInterpreter &interpreter)
1657 {
1658     m_ssh = false;
1659     m_ssh_opts.clear();
1660 }
1661
1662 lldb_private::Error
1663 OptionGroupPlatformSSH::SetOptionValue (CommandInterpreter &interpreter,
1664                                           uint32_t option_idx,
1665                                           const char *option_arg)
1666 {
1667     Error error;
1668     char short_option = (char) GetDefinitions()[option_idx].short_option;
1669     switch (short_option)
1670     {
1671         case 's':
1672             m_ssh = true;
1673             break;
1674
1675         case 'S':
1676             m_ssh_opts.assign(option_arg);
1677             break;
1678
1679         default:
1680             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1681             break;
1682     }
1683
1684     return error;
1685 }
1686
1687 uint32_t
1688 OptionGroupPlatformSSH::GetNumDefinitions ()
1689 {
1690     return llvm::array_lengthof(g_ssh_option_table);
1691 }
1692
1693 const lldb_private::OptionDefinition*
1694 OptionGroupPlatformCaching::GetDefinitions ()
1695 {
1696     return g_caching_option_table;
1697 }
1698
1699 void
1700 OptionGroupPlatformCaching::OptionParsingStarting (CommandInterpreter &interpreter)
1701 {
1702     m_cache_dir.clear();
1703 }
1704
1705 lldb_private::Error
1706 OptionGroupPlatformCaching::SetOptionValue (CommandInterpreter &interpreter,
1707                                         uint32_t option_idx,
1708                                         const char *option_arg)
1709 {
1710     Error error;
1711     char short_option = (char) GetDefinitions()[option_idx].short_option;
1712     switch (short_option)
1713     {
1714         case 'c':
1715             m_cache_dir.assign(option_arg);
1716             break;
1717
1718         default:
1719             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1720             break;
1721     }
1722
1723     return error;
1724 }
1725
1726 uint32_t
1727 OptionGroupPlatformCaching::GetNumDefinitions ()
1728 {
1729     return llvm::array_lengthof(g_caching_option_table);
1730 }
1731
1732 size_t
1733 Platform::GetEnvironment (StringList &environment)
1734 {
1735     environment.Clear();
1736     return false;
1737 }
1738
1739 const std::vector<ConstString> &
1740 Platform::GetTrapHandlerSymbolNames ()
1741 {
1742     if (!m_calculated_trap_handlers)
1743     {
1744         std::lock_guard<std::mutex> guard(m_mutex);
1745         if (!m_calculated_trap_handlers)
1746         {
1747             CalculateTrapHandlerSymbolNames();
1748             m_calculated_trap_handlers = true;
1749         }
1750     }
1751     return m_trap_handlers;
1752 }
1753
1754 Error
1755 Platform::GetCachedExecutable (ModuleSpec &module_spec,
1756                                lldb::ModuleSP &module_sp,
1757                                const FileSpecList *module_search_paths_ptr,
1758                                Platform &remote_platform)
1759 {
1760     const auto platform_spec = module_spec.GetFileSpec ();
1761     const auto error = LoadCachedExecutable (module_spec,
1762                                              module_sp,
1763                                              module_search_paths_ptr,
1764                                              remote_platform);
1765     if (error.Success ())
1766     {
1767         module_spec.GetFileSpec () = module_sp->GetFileSpec ();
1768         module_spec.GetPlatformFileSpec () = platform_spec;
1769     }
1770
1771     return error;
1772 }
1773
1774 Error
1775 Platform::LoadCachedExecutable (const ModuleSpec &module_spec,
1776                                 lldb::ModuleSP &module_sp,
1777                                 const FileSpecList *module_search_paths_ptr,
1778                                 Platform &remote_platform)
1779 {
1780     return GetRemoteSharedModule (module_spec,
1781                                   nullptr,
1782                                   module_sp,
1783                                   [&](const ModuleSpec &spec)
1784                                   {
1785                                       return remote_platform.ResolveExecutable (
1786                                           spec, module_sp, module_search_paths_ptr);
1787                                   },
1788                                   nullptr);
1789 }
1790
1791 Error
1792 Platform::GetRemoteSharedModule (const ModuleSpec &module_spec,
1793                                  Process* process,
1794                                  lldb::ModuleSP &module_sp,
1795                                  const ModuleResolver &module_resolver,
1796                                  bool *did_create_ptr)
1797 {
1798     // Get module information from a target.
1799     ModuleSpec resolved_module_spec;
1800     bool got_module_spec = false;
1801     if (process)
1802     {
1803         // Try to get module information from the process
1804         if (process->GetModuleSpec (module_spec.GetFileSpec (), module_spec.GetArchitecture (), resolved_module_spec))
1805         {
1806             if (module_spec.GetUUID().IsValid() == false || module_spec.GetUUID() == resolved_module_spec.GetUUID())
1807             {
1808                 got_module_spec = true;
1809             }
1810         }
1811     }
1812
1813     if (!got_module_spec)
1814     {
1815         // Get module information from a target.
1816         if (!GetModuleSpec (module_spec.GetFileSpec (), module_spec.GetArchitecture (), resolved_module_spec))
1817         {
1818             if (module_spec.GetUUID().IsValid() == false || module_spec.GetUUID() == resolved_module_spec.GetUUID())
1819             {
1820                 return module_resolver (module_spec);
1821             }
1822         }
1823     }
1824
1825     // If we are looking for a specific UUID, make sure resolved_module_spec has the same one before we search.
1826     if (module_spec.GetUUID().IsValid())
1827     {
1828         resolved_module_spec.GetUUID() = module_spec.GetUUID();
1829     }
1830
1831     // Trying to find a module by UUID on local file system.
1832     const auto error = module_resolver (resolved_module_spec);
1833     if (error.Fail ())
1834      {
1835           if (GetCachedSharedModule (resolved_module_spec, module_sp, did_create_ptr))
1836               return Error ();
1837      }
1838
1839     return error;
1840 }
1841
1842 bool
1843 Platform::GetCachedSharedModule (const ModuleSpec &module_spec,
1844                                  lldb::ModuleSP &module_sp,
1845                                  bool *did_create_ptr)
1846 {
1847     if (IsHost() ||
1848         !GetGlobalPlatformProperties ()->GetUseModuleCache () ||
1849         !GetGlobalPlatformProperties ()->GetModuleCacheDirectory ())
1850         return false;
1851
1852     Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
1853
1854     // Check local cache for a module.
1855     auto error = m_module_cache->GetAndPut (
1856         GetModuleCacheRoot (),
1857         GetCacheHostname (),
1858         module_spec,
1859         [this](const ModuleSpec &module_spec, const FileSpec &tmp_download_file_spec)
1860         {
1861             return DownloadModuleSlice (module_spec.GetFileSpec (),
1862                                         module_spec.GetObjectOffset (),
1863                                         module_spec.GetObjectSize (),
1864                                         tmp_download_file_spec);
1865
1866         },
1867         [this](const ModuleSP& module_sp, const FileSpec& tmp_download_file_spec)
1868         {
1869             return DownloadSymbolFile (module_sp, tmp_download_file_spec);
1870         },
1871         module_sp,
1872         did_create_ptr);
1873     if (error.Success ())
1874         return true;
1875
1876     if (log)
1877         log->Printf("Platform::%s - module %s not found in local cache: %s",
1878                     __FUNCTION__, module_spec.GetUUID ().GetAsString ().c_str (), error.AsCString ());
1879     return false;
1880 }
1881
1882 Error
1883 Platform::DownloadModuleSlice (const FileSpec& src_file_spec,
1884                                const uint64_t src_offset,
1885                                const uint64_t src_size,
1886                                const FileSpec& dst_file_spec)
1887 {
1888     Error error;
1889
1890     std::ofstream dst (dst_file_spec.GetPath(), std::ios::out | std::ios::binary);
1891     if (!dst.is_open())
1892     {
1893         error.SetErrorStringWithFormat ("unable to open destination file: %s", dst_file_spec.GetPath ().c_str ());
1894         return error;
1895     }
1896
1897     auto src_fd = OpenFile (src_file_spec,
1898                             File::eOpenOptionRead,
1899                             lldb::eFilePermissionsFileDefault,
1900                             error);
1901
1902    if (error.Fail ())
1903    {
1904        error.SetErrorStringWithFormat ("unable to open source file: %s", error.AsCString ());
1905        return error;
1906    }
1907
1908     std::vector<char> buffer (1024);
1909     auto offset = src_offset;
1910     uint64_t total_bytes_read = 0;
1911     while (total_bytes_read < src_size)
1912     {
1913         const auto to_read = std::min (static_cast<uint64_t>(buffer.size ()), src_size - total_bytes_read);
1914         const uint64_t n_read = ReadFile (src_fd, offset, &buffer[0], to_read, error);
1915         if (error.Fail ())
1916             break;
1917         if (n_read == 0)
1918         {
1919             error.SetErrorString ("read 0 bytes");
1920             break;
1921         }
1922         offset += n_read;
1923         total_bytes_read += n_read;
1924         dst.write (&buffer[0], n_read);
1925     }
1926
1927     Error close_error;
1928     CloseFile (src_fd, close_error);  // Ignoring close error.
1929
1930     return error;
1931 }
1932
1933 Error
1934 Platform::DownloadSymbolFile (const lldb::ModuleSP& module_sp, const FileSpec& dst_file_spec)
1935 {
1936     return Error ("Symbol file downloading not supported by the default platform.");
1937 }
1938
1939 FileSpec
1940 Platform::GetModuleCacheRoot ()
1941 {
1942     auto dir_spec = GetGlobalPlatformProperties ()->GetModuleCacheDirectory ();
1943     dir_spec.AppendPathComponent (GetName ().AsCString ());
1944     return dir_spec;
1945 }
1946
1947 const char *
1948 Platform::GetCacheHostname ()
1949 {
1950     return GetHostname ();
1951 }
1952
1953 const UnixSignalsSP &
1954 Platform::GetRemoteUnixSignals()
1955 {
1956     static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>();
1957     return s_default_unix_signals_sp;
1958 }
1959
1960 const UnixSignalsSP &
1961 Platform::GetUnixSignals()
1962 {
1963     if (IsHost())
1964         return Host::GetUnixSignals();
1965     return GetRemoteUnixSignals();
1966 }
1967
1968 uint32_t
1969 Platform::LoadImage(lldb_private::Process* process,
1970                     const lldb_private::FileSpec& local_file,
1971                     const lldb_private::FileSpec& remote_file,
1972                     lldb_private::Error& error)
1973 {
1974     if (local_file && remote_file)
1975     {
1976         // Both local and remote file was specified. Install the local file to the given location.
1977         if (IsRemote() || local_file != remote_file)
1978         {
1979             error = Install(local_file, remote_file);
1980             if (error.Fail())
1981                 return LLDB_INVALID_IMAGE_TOKEN;
1982         }
1983         return DoLoadImage(process, remote_file, error);
1984     }
1985
1986     if (local_file)
1987     {
1988         // Only local file was specified. Install it to the current working directory.
1989         FileSpec target_file = GetWorkingDirectory();
1990         target_file.AppendPathComponent(local_file.GetFilename().AsCString());
1991         if (IsRemote() || local_file != target_file)
1992         {
1993             error = Install(local_file, target_file);
1994             if (error.Fail())
1995                 return LLDB_INVALID_IMAGE_TOKEN;
1996         }
1997         return DoLoadImage(process, target_file, error);
1998     }
1999
2000     if (remote_file)
2001     {
2002         // Only remote file was specified so we don't have to do any copying
2003         return DoLoadImage(process, remote_file, error);
2004     }
2005
2006     error.SetErrorString("Neither local nor remote file was specified");
2007     return LLDB_INVALID_IMAGE_TOKEN;
2008 }
2009
2010 uint32_t
2011 Platform::DoLoadImage (lldb_private::Process* process,
2012                        const lldb_private::FileSpec& remote_file,
2013                        lldb_private::Error& error)
2014 {
2015     error.SetErrorString("LoadImage is not supported on the current platform");
2016     return LLDB_INVALID_IMAGE_TOKEN;
2017 }
2018
2019 Error
2020 Platform::UnloadImage(lldb_private::Process* process, uint32_t image_token)
2021 {
2022     return Error("UnloadImage is not supported on the current platform");
2023 }
2024
2025 lldb::ProcessSP
2026 Platform::ConnectProcess(const char* connect_url,
2027                          const char* plugin_name,
2028                          lldb_private::Debugger &debugger,
2029                          lldb_private::Target *target,
2030                          lldb_private::Error &error)
2031 {
2032     error.Clear();
2033
2034     if (!target)
2035     {
2036         TargetSP new_target_sp;
2037         error = debugger.GetTargetList().CreateTarget(debugger,
2038                                                       nullptr,
2039                                                       nullptr,
2040                                                       false,
2041                                                       nullptr,
2042                                                       new_target_sp);
2043         target = new_target_sp.get();
2044     }
2045
2046     if (!target || error.Fail())
2047         return nullptr;
2048
2049     debugger.GetTargetList().SetSelectedTarget(target);
2050
2051     lldb::ProcessSP process_sp = target->CreateProcess(debugger.GetListener(),
2052                                                        plugin_name,
2053                                                        nullptr);
2054     if (!process_sp)
2055         return nullptr;
2056
2057     error = process_sp->ConnectRemote(debugger.GetOutputFile().get(), connect_url);
2058     if (error.Fail())
2059         return nullptr;
2060
2061     return process_sp;
2062 }
2063
2064 size_t
2065 Platform::ConnectToWaitingProcesses(lldb_private::Debugger& debugger, lldb_private::Error& error)
2066 {
2067     error.Clear();
2068     return 0;
2069 }
2070
2071 size_t
2072 Platform::GetSoftwareBreakpointTrapOpcode(Target &target, BreakpointSite *bp_site)
2073 {
2074     ArchSpec arch = target.GetArchitecture();
2075     const uint8_t *trap_opcode = nullptr;
2076     size_t trap_opcode_size = 0;
2077
2078     switch (arch.GetMachine())
2079     {
2080     case llvm::Triple::aarch64:
2081         {
2082             static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4};
2083             trap_opcode = g_aarch64_opcode;
2084             trap_opcode_size = sizeof(g_aarch64_opcode);
2085         }
2086         break;
2087
2088     // TODO: support big-endian arm and thumb trap codes.
2089     case llvm::Triple::arm:
2090         {
2091             // The ARM reference recommends the use of 0xe7fddefe and 0xdefe
2092             // but the linux kernel does otherwise.
2093             static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
2094             static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
2095
2096             lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
2097             AddressClass addr_class = eAddressClassUnknown;
2098
2099             if (bp_loc_sp)
2100             {
2101                 addr_class = bp_loc_sp->GetAddress().GetAddressClass();
2102                 if (addr_class == eAddressClassUnknown && (bp_loc_sp->GetAddress().GetFileAddress() & 1))
2103                     addr_class = eAddressClassCodeAlternateISA;
2104             }
2105
2106             if (addr_class == eAddressClassCodeAlternateISA)
2107             {
2108                 trap_opcode = g_thumb_breakpoint_opcode;
2109                 trap_opcode_size = sizeof(g_thumb_breakpoint_opcode);
2110             }
2111             else
2112             {
2113                 trap_opcode = g_arm_breakpoint_opcode;
2114                 trap_opcode_size = sizeof(g_arm_breakpoint_opcode);
2115             }
2116         }
2117         break;
2118
2119     case llvm::Triple::mips:
2120     case llvm::Triple::mips64:
2121         {
2122             static const uint8_t g_hex_opcode[] = {0x00, 0x00, 0x00, 0x0d};
2123             trap_opcode = g_hex_opcode;
2124             trap_opcode_size = sizeof(g_hex_opcode);
2125         }
2126         break;
2127
2128     case llvm::Triple::mipsel:
2129     case llvm::Triple::mips64el:
2130         {
2131             static const uint8_t g_hex_opcode[] = {0x0d, 0x00, 0x00, 0x00};
2132             trap_opcode = g_hex_opcode;
2133             trap_opcode_size = sizeof(g_hex_opcode);
2134         }
2135         break;
2136
2137     case llvm::Triple::systemz:
2138         {
2139             static const uint8_t g_hex_opcode[] = {0x00, 0x01};
2140             trap_opcode = g_hex_opcode;
2141             trap_opcode_size = sizeof(g_hex_opcode);
2142         }
2143         break;
2144
2145     case llvm::Triple::hexagon:
2146         {
2147             static const uint8_t g_hex_opcode[] = {0x0c, 0xdb, 0x00, 0x54};
2148             trap_opcode = g_hex_opcode;
2149             trap_opcode_size = sizeof(g_hex_opcode);
2150         }
2151         break;
2152
2153     case llvm::Triple::ppc:
2154     case llvm::Triple::ppc64:
2155         {
2156             static const uint8_t g_ppc_opcode[] = {0x7f, 0xe0, 0x00, 0x08};
2157             trap_opcode = g_ppc_opcode;
2158             trap_opcode_size = sizeof(g_ppc_opcode);
2159         }
2160         break;
2161
2162     case llvm::Triple::x86:
2163     case llvm::Triple::x86_64:
2164         {
2165             static const uint8_t g_i386_opcode[] = {0xCC};
2166             trap_opcode = g_i386_opcode;
2167             trap_opcode_size = sizeof(g_i386_opcode);
2168         }
2169         break;
2170
2171     default:
2172         assert(!"Unhandled architecture in Platform::GetSoftwareBreakpointTrapOpcode");
2173         break;
2174     }
2175
2176     assert(bp_site);
2177     if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size))
2178         return trap_opcode_size;
2179
2180     return 0;
2181 }