/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Target/Platform.cpp

Bug Summary

File:	tools/lldb/source/Target/Platform.cpp
Warning:	line 1063, column 9 Inner pointer of container used after re/deallocation
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Platform.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/source/Target -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Target -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/source/Target -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Target/Platform.cpp -faddrsig
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//===----------------------------------------------------------------------===//

10// C Includes
11// C++ Includes
12#include <algorithm>
13#include <csignal>
14#include <fstream>
15#include <vector>

17// Other libraries and framework includes
18#include "llvm/Support/FileSystem.h"
19#include "llvm/Support/Path.h"

21// Project includes
22#include "lldb/Breakpoint/BreakpointIDList.h"
23#include "lldb/Breakpoint/BreakpointLocation.h"
24#include "lldb/Core/Debugger.h"
25#include "lldb/Core/Module.h"
26#include "lldb/Core/ModuleSpec.h"
27#include "lldb/Core/PluginManager.h"
28#include "lldb/Core/StreamFile.h"
29#include "lldb/Host/FileSystem.h"
30#include "lldb/Host/Host.h"
31#include "lldb/Host/HostInfo.h"
32#include "lldb/Host/OptionParser.h"
33#include "lldb/Interpreter/OptionValueProperties.h"
34#include "lldb/Interpreter/Property.h"
35#include "lldb/Symbol/ObjectFile.h"
36#include "lldb/Target/ModuleCache.h"
37#include "lldb/Target/Platform.h"
38#include "lldb/Target/Process.h"
39#include "lldb/Target/Target.h"
40#include "lldb/Target/UnixSignals.h"
41#include "lldb/Utility/DataBufferHeap.h"
42#include "lldb/Utility/FileSpec.h"
43#include "lldb/Utility/Log.h"
44#include "lldb/Utility/Status.h"
45#include "lldb/Utility/StructuredData.h"

47#include "llvm/Support/FileSystem.h"

49// Define these constants from POSIX mman.h rather than include the file so
50// that they will be correct even when compiled on Linux.
51#define MAP_PRIVATE2 2
52#define MAP_ANON0x1000 0x1000

54using namespace lldb;
55using namespace lldb_private;

57static uint32_t g_initialize_count = 0;

59// Use a singleton function for g_local_platform_sp to avoid init constructors
60// since LLDB is often part of a shared library
61static PlatformSP &GetHostPlatformSP() {
static PlatformSP g_platform_sp;
return g_platform_sp;
64}

66const char *Platform::GetHostPlatformName() { return "host"; }

68namespace {

70static constexpr PropertyDefinition g_properties[] = {
  {"use-module-cache", OptionValue::eTypeBoolean, true, true, nullptr,
   {}, "Use module cache."},
  {"module-cache-directory", OptionValue::eTypeFileSpec, true, 0, nullptr,
   {}, "Root directory for cached modules."}};

76enum { ePropertyUseModuleCache, ePropertyModuleCacheDirectory };

78} // namespace

80ConstString PlatformProperties::GetSettingName() {
static ConstString g_setting_name("platform");
return g_setting_name;
83}

85PlatformProperties::PlatformProperties() {
m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
m_collection_sp->Initialize(g_properties);

auto module_cache_dir = GetModuleCacheDirectory();
if (module_cache_dir)
  return;

llvm::SmallString<64> user_home_dir;
if (!llvm::sys::path::home_directory(user_home_dir))
  return;

module_cache_dir = FileSpec(user_home_dir.c_str(), false);
module_cache_dir.AppendPathComponent(".lldb");
module_cache_dir.AppendPathComponent("module_cache");
SetModuleCacheDirectory(module_cache_dir);
101}

103bool PlatformProperties::GetUseModuleCache() const {
const auto idx = ePropertyUseModuleCache;
return m_collection_sp->GetPropertyAtIndexAsBoolean(
    nullptr, idx, g_properties[idx].default_uint_value != 0);
107}

109bool PlatformProperties::SetUseModuleCache(bool use_module_cache) {
return m_collection_sp->SetPropertyAtIndexAsBoolean(
    nullptr, ePropertyUseModuleCache, use_module_cache);
112}

114FileSpec PlatformProperties::GetModuleCacheDirectory() const {
return m_collection_sp->GetPropertyAtIndexAsFileSpec(
    nullptr, ePropertyModuleCacheDirectory);
117}

119bool PlatformProperties::SetModuleCacheDirectory(const FileSpec &dir_spec) {
return m_collection_sp->SetPropertyAtIndexAsFileSpec(
    nullptr, ePropertyModuleCacheDirectory, dir_spec);
122}

124//------------------------------------------------------------------
125/// Get the native host platform plug-in.
126///
127/// There should only be one of these for each host that LLDB runs
128/// upon that should be statically compiled in and registered using
129/// preprocessor macros or other similar build mechanisms.
130///
131/// This platform will be used as the default platform when launching
132/// or attaching to processes unless another platform is specified.
133//------------------------------------------------------------------
134PlatformSP Platform::GetHostPlatform() { return GetHostPlatformSP(); }

136static std::vector<PlatformSP> &GetPlatformList() {
static std::vector<PlatformSP> g_platform_list;
return g_platform_list;
139}

141static std::recursive_mutex &GetPlatformListMutex() {
static std::recursive_mutex g_mutex;
return g_mutex;
144}

146void Platform::Initialize() { g_initialize_count++; }

148void Platform::Terminate() {
if (g_initialize_count > 0) {
  if (--g_initialize_count == 0) {
    std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
    GetPlatformList().clear();
  }
}
155}

157const PlatformPropertiesSP &Platform::GetGlobalPlatformProperties() {
static const auto g_settings_sp(std::make_shared<PlatformProperties>());
return g_settings_sp;
160}

162void Platform::SetHostPlatform(const lldb::PlatformSP &platform_sp) {
// The native platform should use its static void Platform::Initialize()
// function to register itself as the native platform.
GetHostPlatformSP() = platform_sp;

if (platform_sp) {
  std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
  GetPlatformList().push_back(platform_sp);
}
171}

173Status Platform::GetFileWithUUID(const FileSpec &platform_file,
                               const UUID *uuid_ptr, FileSpec &local_file) {
// Default to the local case
local_file = platform_file;
return Status();
178}

180FileSpecList
181Platform::LocateExecutableScriptingResources(Target *target, Module &module,
                                           Stream *feedback_stream) {
return FileSpecList();
184}

186// PlatformSP
187// Platform::FindPlugin (Process *process, const ConstString &plugin_name)
188//{
189//    PlatformCreateInstance create_callback = nullptr;
190//    if (plugin_name)
191//    {
192//        create_callback  =
193//        PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name);
194//        if (create_callback)
195//        {
196//            ArchSpec arch;
197//            if (process)
198//            {
199//                arch = process->GetTarget().GetArchitecture();
200//            }
201//            PlatformSP platform_sp(create_callback(process, &arch));
202//            if (platform_sp)
203//                return platform_sp;
204//        }
205//    }
206//    else
207//    {
208//        for (uint32_t idx = 0; (create_callback =
209//        PluginManager::GetPlatformCreateCallbackAtIndex(idx)) != nullptr;
210//        ++idx)
211//        {
212//            PlatformSP platform_sp(create_callback(process, nullptr));
213//            if (platform_sp)
214//                return platform_sp;
215//        }
216//    }
217//    return PlatformSP();
218//}

220Status Platform::GetSharedModule(const ModuleSpec &module_spec,
                               Process *process, ModuleSP &module_sp,
                               const FileSpecList *module_search_paths_ptr,
                               ModuleSP *old_module_sp_ptr,
                               bool *did_create_ptr) {
if (IsHost())
  return ModuleList::GetSharedModule(
      module_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr,
      did_create_ptr, false);

// Module resolver lambda.
auto resolver = [&](const ModuleSpec &spec) {
  Status error(eErrorTypeGeneric);
  ModuleSpec resolved_spec;
  // Check if we have sysroot set.
  if (m_sdk_sysroot) {
    // Prepend sysroot to module spec.
    resolved_spec = spec;
    resolved_spec.GetFileSpec().PrependPathComponent(
        m_sdk_sysroot.GetStringRef());
    // Try to get shared module with resolved spec.
    error = ModuleList::GetSharedModule(
        resolved_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr,
        did_create_ptr, false);
  }
  // If we don't have sysroot or it didn't work then
  // try original module spec.
  if (!error.Success()) {
    resolved_spec = spec;
    error = ModuleList::GetSharedModule(
        resolved_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr,
        did_create_ptr, false);
  }
  if (error.Success() && module_sp)
    module_sp->SetPlatformFileSpec(resolved_spec.GetFileSpec());
  return error;
};

return GetRemoteSharedModule(module_spec, process, module_sp, resolver,
                             did_create_ptr);
260}

262bool Platform::GetModuleSpec(const FileSpec &module_file_spec,
                           const ArchSpec &arch, ModuleSpec &module_spec) {
ModuleSpecList module_specs;
if (ObjectFile::GetModuleSpecifications(module_file_spec, 0, 0,
                                        module_specs) == 0)
  return false;

ModuleSpec matched_module_spec;
return module_specs.FindMatchingModuleSpec(ModuleSpec(module_file_spec, arch),
                                           module_spec);
272}

274PlatformSP Platform::Find(const ConstString &name) {
if (name) {
  static ConstString g_host_platform_name("host");
  if (name == g_host_platform_name)
    return GetHostPlatform();

  std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
  for (const auto &platform_sp : GetPlatformList()) {
    if (platform_sp->GetName() == name)
      return platform_sp;
  }
}
return PlatformSP();
287}

289PlatformSP Platform::Create(const ConstString &name, Status &error) {
PlatformCreateInstance create_callback = nullptr;
lldb::PlatformSP platform_sp;
if (name) {
  static ConstString g_host_platform_name("host");
  if (name == g_host_platform_name)
    return GetHostPlatform();

  create_callback =
      PluginManager::GetPlatformCreateCallbackForPluginName(name);
  if (create_callback)
    platform_sp = create_callback(true, nullptr);
  else
    error.SetErrorStringWithFormat(
        "unable to find a plug-in for the platform named \"%s\"",
        name.GetCString());
} else
  error.SetErrorString("invalid platform name");

if (platform_sp) {
  std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
  GetPlatformList().push_back(platform_sp);
}

return platform_sp;
314}

316PlatformSP Platform::Create(const ArchSpec &arch, ArchSpec *platform_arch_ptr,
                          Status &error) {
lldb::PlatformSP platform_sp;
if (arch.IsValid()) {
  // Scope for locker
  {
    // First try exact arch matches across all platforms already created
    std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
    for (const auto &platform_sp : GetPlatformList()) {
      if (platform_sp->IsCompatibleArchitecture(arch, true,
                                                platform_arch_ptr))
        return platform_sp;
    }

    // Next try compatible arch matches across all platforms already created
    for (const auto &platform_sp : GetPlatformList()) {
      if (platform_sp->IsCompatibleArchitecture(arch, false,
                                                platform_arch_ptr))
        return platform_sp;
    }
  }

  PlatformCreateInstance create_callback;
  // First try exact arch matches across all platform plug-ins
  uint32_t idx;
  for (idx = 0; (create_callback =
                     PluginManager::GetPlatformCreateCallbackAtIndex(idx));
       ++idx) {
    if (create_callback) {
      platform_sp = create_callback(false, &arch);
      if (platform_sp &&
          platform_sp->IsCompatibleArchitecture(arch, true,
                                                platform_arch_ptr)) {
        std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
        GetPlatformList().push_back(platform_sp);
        return platform_sp;
      }
    }
  }
  // Next try compatible arch matches across all platform plug-ins
  for (idx = 0; (create_callback =
                     PluginManager::GetPlatformCreateCallbackAtIndex(idx));
       ++idx) {
    if (create_callback) {
      platform_sp = create_callback(false, &arch);
      if (platform_sp &&
          platform_sp->IsCompatibleArchitecture(arch, false,
                                                platform_arch_ptr)) {
        std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
        GetPlatformList().push_back(platform_sp);
        return platform_sp;
      }
    }
  }
} else
  error.SetErrorString("invalid platform name");
if (platform_arch_ptr)
  platform_arch_ptr->Clear();
platform_sp.reset();
return platform_sp;
376}

378ArchSpec Platform::GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple) {
if (platform)
  return platform->GetAugmentedArchSpec(triple);
return HostInfo::GetAugmentedArchSpec(triple);
382}

384//------------------------------------------------------------------
385/// Default Constructor
386//------------------------------------------------------------------
387Platform::Platform(bool is_host)
  : m_is_host(is_host), m_os_version_set_while_connected(false),
    m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
    m_working_dir(), m_remote_url(), m_name(), m_system_arch(), m_mutex(),
    m_uid_map(), m_gid_map(), m_max_uid_name_len(0), m_max_gid_name_len(0),
    m_supports_rsync(false), m_rsync_opts(), m_rsync_prefix(),
    m_supports_ssh(false), m_ssh_opts(), m_ignores_remote_hostname(false),
    m_trap_handlers(), m_calculated_trap_handlers(false),
    m_module_cache(llvm::make_unique<ModuleCache>()) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT(1u << 11)));
if (log)
  log->Printf("%p Platform::Platform()", static_cast<void *>(this));
399}

401//------------------------------------------------------------------
402/// Destructor.
403///
404/// The destructor is virtual since this class is designed to be
405/// inherited from by the plug-in instance.
406//------------------------------------------------------------------
407Platform::~Platform() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT(1u << 11)));
if (log)
  log->Printf("%p Platform::~Platform()", static_cast<void *>(this));
411}

413void Platform::GetStatus(Stream &strm) {
std::string s;
strm.Printf("  Platform: %s\n", GetPluginName().GetCString());

ArchSpec arch(GetSystemArchitecture());
if (arch.IsValid()) {
  if (!arch.GetTriple().str().empty()) {
    strm.Printf("    Triple: ");
    arch.DumpTriple(strm);
    strm.EOL();
  }
}

llvm::VersionTuple os_version = GetOSVersion();
if (!os_version.empty()) {
  strm.Format("OS Version: {0}", os_version.getAsString());

  if (GetOSBuildString(s))
    strm.Printf(" (%s)", s.c_str());

  strm.EOL();
}

if (GetOSKernelDescription(s))
  strm.Printf("    Kernel: %s\n", s.c_str());

if (IsHost()) {
  strm.Printf("  Hostname: %s\n", GetHostname());
} else {
  const bool is_connected = IsConnected();
  if (is_connected)
    strm.Printf("  Hostname: %s\n", GetHostname());
  strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
}

if (GetWorkingDirectory()) {
  strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
}
if (!IsConnected())
  return;

std::string specific_info(GetPlatformSpecificConnectionInformation());

if (!specific_info.empty())
  strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
458}

460llvm::VersionTuple Platform::GetOSVersion(Process *process) {
std::lock_guard<std::mutex> guard(m_mutex);

if (IsHost()) {
  if (m_os_version.empty()) {
    // We have a local host platform
    m_os_version = HostInfo::GetOSVersion();
    m_os_version_set_while_connected = !m_os_version.empty();
  }
} else {
  // We have a remote platform. We can only fetch the remote
  // OS version if we are connected, and we don't want to do it
  // more than once.

  const bool is_connected = IsConnected();

  bool fetch = false;
  if (!m_os_version.empty()) {
    // We have valid OS version info, check to make sure it wasn't manually
    // set prior to connecting. If it was manually set prior to connecting,
    // then lets fetch the actual OS version info if we are now connected.
    if (is_connected && !m_os_version_set_while_connected)
      fetch = true;
  } else {
    // We don't have valid OS version info, fetch it if we are connected
    fetch = is_connected;
  }

  if (fetch)
    m_os_version_set_while_connected = GetRemoteOSVersion();
}

if (!m_os_version.empty())
  return m_os_version;
if (process) {
  // Check with the process in case it can answer the question if a process
  // was provided
  return process->GetHostOSVersion();
}
return llvm::VersionTuple();
500}

502bool Platform::GetOSBuildString(std::string &s) {
s.clear();

if (IsHost())
506#if !defined(__linux__1)
  return HostInfo::GetOSBuildString(s);
508#else
  return false;
510#endif
else
  return GetRemoteOSBuildString(s);
513}

515bool Platform::GetOSKernelDescription(std::string &s) {
if (IsHost())
517#if !defined(__linux__1)
  return HostInfo::GetOSKernelDescription(s);
519#else
  return false;
521#endif
else
  return GetRemoteOSKernelDescription(s);
524}

526void Platform::AddClangModuleCompilationOptions(
  Target *target, std::vector<std::string> &options) {
std::vector<std::string> default_compilation_options = {
    "-x", "c++", "-Xclang", "-nostdsysteminc", "-Xclang", "-nostdsysteminc"};

options.insert(options.end(), default_compilation_options.begin(),
               default_compilation_options.end());
533}

535FileSpec Platform::GetWorkingDirectory() {
if (IsHost()) {
  llvm::SmallString<64> cwd;
  if (llvm::sys::fs::current_path(cwd))
    return FileSpec{};
  else
    return FileSpec(cwd, true);
} else {
  if (!m_working_dir)
    m_working_dir = GetRemoteWorkingDirectory();
  return m_working_dir;
}
547}

549struct RecurseCopyBaton {
const FileSpec &dst;
Platform *platform_ptr;
Status error;
553};

555static FileSpec::EnumerateDirectoryResult
556RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft,
                   const FileSpec &src) {
RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton;
namespace fs = llvm::sys::fs;
switch (ft) {
case fs::file_type::fifo_file:
case fs::file_type::socket_file:
  // we have no way to copy pipes and sockets - ignore them and continue
  return FileSpec::eEnumerateDirectoryResultNext;
  break;

case fs::file_type::directory_file: {
  // make the new directory and get in there
  FileSpec dst_dir = rc_baton->dst;
  if (!dst_dir.GetFilename())
    dst_dir.GetFilename() = src.GetLastPathComponent();
  Status error = rc_baton->platform_ptr->MakeDirectory(
      dst_dir, lldb::eFilePermissionsDirectoryDefault);
  if (error.Fail()) {
    rc_baton->error.SetErrorStringWithFormat(
        "unable to setup directory %s on remote end", dst_dir.GetCString());
    return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
  }

  // now recurse
  std::string src_dir_path(src.GetPath());

  // Make a filespec that only fills in the directory of a FileSpec so when
  // we enumerate we can quickly fill in the filename for dst copies
  FileSpec recurse_dst;
  recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
  RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr,
                                Status()};
  FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
                               RecurseCopy_Callback, &rc_baton2);
  if (rc_baton2.error.Fail()) {
    rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
    return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
  }
  return FileSpec::eEnumerateDirectoryResultNext;
} break;

case fs::file_type::symlink_file: {
  // copy the file and keep going
  FileSpec dst_file = rc_baton->dst;
  if (!dst_file.GetFilename())
    dst_file.GetFilename() = src.GetFilename();

  FileSpec src_resolved;

  rc_baton->error = FileSystem::Readlink(src, src_resolved);

  if (rc_baton->error.Fail())
    return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out

  rc_baton->error =
      rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);

  if (rc_baton->error.Fail())
    return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out

  return FileSpec::eEnumerateDirectoryResultNext;
} break;

case fs::file_type::regular_file: {
  // copy the file and keep going
  FileSpec dst_file = rc_baton->dst;
  if (!dst_file.GetFilename())
    dst_file.GetFilename() = src.GetFilename();
  Status err = rc_baton->platform_ptr->PutFile(src, dst_file);
  if (err.Fail()) {
    rc_baton->error.SetErrorString(err.AsCString());
    return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
  }
  return FileSpec::eEnumerateDirectoryResultNext;
} break;

default:
  rc_baton->error.SetErrorStringWithFormat(
      "invalid file detected during copy: %s", src.GetPath().c_str());
  return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
  break;
}
llvm_unreachable("Unhandled file_type!")::llvm::llvm_unreachable_internal("Unhandled file_type!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Target/Platform.cpp"
, 639);
640}

642Status Platform::Install(const FileSpec &src, const FileSpec &dst) {
Status error;

Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM(1u << 25));
if (log)
  log->Printf("Platform::Install (src='%s', dst='%s')", src.GetPath().c_str(),
              dst.GetPath().c_str());
FileSpec fixed_dst(dst);

if (!fixed_dst.GetFilename())
  fixed_dst.GetFilename() = src.GetFilename();

FileSpec working_dir = GetWorkingDirectory();

if (dst) {
  if (dst.GetDirectory()) {
    const char first_dst_dir_char = dst.GetDirectory().GetCString()[0];
    if (first_dst_dir_char == '/' || first_dst_dir_char == '\\') {
      fixed_dst.GetDirectory() = dst.GetDirectory();
    }
    // If the fixed destination file doesn't have a directory yet, then we
    // must have a relative path. We will resolve this relative path against
    // the platform's working directory
    if (!fixed_dst.GetDirectory()) {
      FileSpec relative_spec;
      std::string path;
      if (working_dir) {
        relative_spec = working_dir;
        relative_spec.AppendPathComponent(dst.GetPath());
        fixed_dst.GetDirectory() = relative_spec.GetDirectory();
      } else {
        error.SetErrorStringWithFormat(
            "platform working directory must be valid for relative path '%s'",
            dst.GetPath().c_str());
        return error;
      }
    }
  } else {
    if (working_dir) {
      fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
    } else {
      error.SetErrorStringWithFormat(
          "platform working directory must be valid for relative path '%s'",
          dst.GetPath().c_str());
      return error;
    }
  }
} else {
  if (working_dir) {
    fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
  } else {
    error.SetErrorStringWithFormat("platform working directory must be valid "
                                   "when destination directory is empty");
    return error;
  }
}

if (log)
  log->Printf("Platform::Install (src='%s', dst='%s') fixed_dst='%s'",
              src.GetPath().c_str(), dst.GetPath().c_str(),
              fixed_dst.GetPath().c_str());

if (GetSupportsRSync()) {
  error = PutFile(src, dst);
} else {
  namespace fs = llvm::sys::fs;
  switch (fs::get_file_type(src.GetPath(), false)) {
  case fs::file_type::directory_file: {
    llvm::sys::fs::remove(fixed_dst.GetPath());
    uint32_t permissions = src.GetPermissions();
    if (permissions == 0)
      permissions = eFilePermissionsDirectoryDefault;
    error = MakeDirectory(fixed_dst, permissions);
    if (error.Success()) {
      // Make a filespec that only fills in the directory of a FileSpec so
      // when we enumerate we can quickly fill in the filename for dst copies
      FileSpec recurse_dst;
      recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
      std::string src_dir_path(src.GetPath());
      RecurseCopyBaton baton = {recurse_dst, this, Status()};
      FileSpec::EnumerateDirectory(src_dir_path, true, true, true,
                                   RecurseCopy_Callback, &baton);
      return baton.error;
    }
  } break;

  case fs::file_type::regular_file:
    llvm::sys::fs::remove(fixed_dst.GetPath());
    error = PutFile(src, fixed_dst);
    break;

  case fs::file_type::symlink_file: {
    llvm::sys::fs::remove(fixed_dst.GetPath());
    FileSpec src_resolved;
    error = FileSystem::Readlink(src, src_resolved);
    if (error.Success())
      error = CreateSymlink(dst, src_resolved);
  } break;
  case fs::file_type::fifo_file:
    error.SetErrorString("platform install doesn't handle pipes");
    break;
  case fs::file_type::socket_file:
    error.SetErrorString("platform install doesn't handle sockets");
    break;
  default:
    error.SetErrorString(
        "platform install doesn't handle non file or directory items");
    break;
  }
}
return error;
753}

755bool Platform::SetWorkingDirectory(const FileSpec &file_spec) {
if (IsHost()) {
  Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM(1u << 25));
  LLDB_LOG(log, "{0}", file_spec)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Target/Platform.cpp"
, __func__, "{0}", file_spec); } while (0);
  if (std::error_code ec = llvm::sys::fs::set_current_path(file_spec.GetPath())) {
    LLDB_LOG(log, "error: {0}", ec.message())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Target/Platform.cpp"
, __func__, "error: {0}", ec.message()); } while (0);
    return false;
  }
  return true;
} else {
  m_working_dir.Clear();
  return SetRemoteWorkingDirectory(file_spec);
}
768}

770Status Platform::MakeDirectory(const FileSpec &file_spec,
                             uint32_t permissions) {
if (IsHost())
  return llvm::sys::fs::create_directory(file_spec.GetPath(), permissions);
else {
  Status error;
  error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
                                 GetPluginName().GetCString(),
                                 LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
  return error;
}
781}

783Status Platform::GetFilePermissions(const FileSpec &file_spec,
                                  uint32_t &file_permissions) {
if (IsHost()) {
  auto Value = llvm::sys::fs::getPermissions(file_spec.GetPath());
  if (Value)
    file_permissions = Value.get();
  return Status(Value.getError());
} else {
  Status error;
  error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
                                 GetPluginName().GetCString(),
                                 LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
  return error;
}
797}

799Status Platform::SetFilePermissions(const FileSpec &file_spec,
                                  uint32_t file_permissions) {
if (IsHost()) {
  auto Perms = static_cast<llvm::sys::fs::perms>(file_permissions);
  return llvm::sys::fs::setPermissions(file_spec.GetPath(), Perms);
} else {
  Status error;
  error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
                                 GetPluginName().GetCString(),
                                 LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
  return error;
}
811}

813ConstString Platform::GetName() { return GetPluginName(); }

815const char *Platform::GetHostname() {
if (IsHost())
  return "127.0.0.1";

if (m_name.empty())
  return nullptr;
return m_name.c_str();
822}

824ConstString Platform::GetFullNameForDylib(ConstString basename) {
return basename;
826}

828bool Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM(1u << 25));
if (log)
  log->Printf("Platform::SetRemoteWorkingDirectory('%s')",
              working_dir.GetCString());
m_working_dir = working_dir;
return true;
835}

837const char *Platform::GetUserName(uint32_t uid) {
838#if !defined(LLDB_DISABLE_POSIX)
const char *user_name = GetCachedUserName(uid);
if (user_name)
  return user_name;
if (IsHost()) {
  std::string name;
  if (HostInfo::LookupUserName(uid, name))
    return SetCachedUserName(uid, name.c_str(), name.size());
}
847#endif
return nullptr;
849}

851const char *Platform::GetGroupName(uint32_t gid) {
852#if !defined(LLDB_DISABLE_POSIX)
const char *group_name = GetCachedGroupName(gid);
if (group_name)
  return group_name;
if (IsHost()) {
  std::string name;
  if (HostInfo::LookupGroupName(gid, name))
    return SetCachedGroupName(gid, name.c_str(), name.size());
}
861#endif
return nullptr;
863}

865bool Platform::SetOSVersion(llvm::VersionTuple version) {
if (IsHost()) {
  // We don't need anyone setting the OS version for the host platform, we
  // should be able to figure it out by calling HostInfo::GetOSVersion(...).
  return false;
} else {
  // We have a remote platform, allow setting the target OS version if we
  // aren't connected, since if we are connected, we should be able to
  // request the remote OS version from the connected platform.
  if (IsConnected())
    return false;
  else {
    // We aren't connected and we might want to set the OS version ahead of
    // time before we connect so we can peruse files and use a local SDK or
    // PDK cache of support files to disassemble or do other things.
    m_os_version = version;
    return true;
  }
}
return false;
885}

887Status
888Platform::ResolveExecutable(const ModuleSpec &module_spec,
                          lldb::ModuleSP &exe_module_sp,
                          const FileSpecList *module_search_paths_ptr) {
Status error;
if (module_spec.GetFileSpec().Exists()) {
  if (module_spec.GetArchitecture().IsValid()) {
    error = ModuleList::GetSharedModule(module_spec, exe_module_sp,
                                        module_search_paths_ptr, nullptr,
                                        nullptr);
  } else {
    // No valid architecture was specified, ask the platform for the
    // architectures that we should be using (in the correct order) and see
    // if we can find a match that way
    ModuleSpec arch_module_spec(module_spec);
    for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
             idx, arch_module_spec.GetArchitecture());
         ++idx) {
      error = ModuleList::GetSharedModule(arch_module_spec, exe_module_sp,
                                          module_search_paths_ptr, nullptr,
                                          nullptr);
      // Did we find an executable using one of the
      if (error.Success() && exe_module_sp)
        break;
    }
  }
} else {
  error.SetErrorStringWithFormat("'%s' does not exist",
                                 module_spec.GetFileSpec().GetPath().c_str());
}
return error;
918}

920Status Platform::ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
                                 FileSpec &sym_file) {
Status error;
if (sym_spec.GetSymbolFileSpec().Exists())
  sym_file = sym_spec.GetSymbolFileSpec();
else
  error.SetErrorString("unable to resolve symbol file");
return error;
928}

930bool Platform::ResolveRemotePath(const FileSpec &platform_path,
                               FileSpec &resolved_platform_path) {
resolved_platform_path = platform_path;
return resolved_platform_path.ResolvePath();
934}

936const ArchSpec &Platform::GetSystemArchitecture() {
if (IsHost()) {
  if (!m_system_arch.IsValid()) {
    // We have a local host platform
    m_system_arch = HostInfo::GetArchitecture();
    m_system_arch_set_while_connected = m_system_arch.IsValid();
  }
} else {
  // We have a remote platform. We can only fetch the remote system
  // architecture if we are connected, and we don't want to do it more than
  // once.

  const bool is_connected = IsConnected();

  bool fetch = false;
  if (m_system_arch.IsValid()) {
    // We have valid OS version info, check to make sure it wasn't manually
    // set prior to connecting. If it was manually set prior to connecting,
    // then lets fetch the actual OS version info if we are now connected.
    if (is_connected && !m_system_arch_set_while_connected)
      fetch = true;
  } else {
    // We don't have valid OS version info, fetch it if we are connected
    fetch = is_connected;
  }

  if (fetch) {
    m_system_arch = GetRemoteSystemArchitecture();
    m_system_arch_set_while_connected = m_system_arch.IsValid();
  }
}
return m_system_arch;
968}

970ArchSpec Platform::GetAugmentedArchSpec(llvm::StringRef triple) {
if (triple.empty())
  return ArchSpec();
llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
if (!ArchSpec::ContainsOnlyArch(normalized_triple))
  return ArchSpec(triple);

if (auto kind = HostInfo::ParseArchitectureKind(triple))
  return HostInfo::GetArchitecture(*kind);

ArchSpec compatible_arch;
ArchSpec raw_arch(triple);
if (!IsCompatibleArchitecture(raw_arch, false, &compatible_arch))
  return raw_arch;

if (!compatible_arch.IsValid())
  return ArchSpec(normalized_triple);

const llvm::Triple &compatible_triple = compatible_arch.GetTriple();
if (normalized_triple.getVendorName().empty())
  normalized_triple.setVendor(compatible_triple.getVendor());
if (normalized_triple.getOSName().empty())
  normalized_triple.setOS(compatible_triple.getOS());
if (normalized_triple.getEnvironmentName().empty())
  normalized_triple.setEnvironment(compatible_triple.getEnvironment());
return ArchSpec(normalized_triple);
996}

998Status Platform::ConnectRemote(Args &args) {
Status error;
if (IsHost())
  error.SetErrorStringWithFormat("The currently selected platform (%s) is "
                                 "the host platform and is always connected.",
                                 GetPluginName().GetCString());
else
  error.SetErrorStringWithFormat(
      "Platform::ConnectRemote() is not supported by %s",
      GetPluginName().GetCString());
return error;
1009}

1011Status Platform::DisconnectRemote() {
Status error;
if (IsHost())
  error.SetErrorStringWithFormat("The currently selected platform (%s) is "
                                 "the host platform and is always connected.",
                                 GetPluginName().GetCString());
else
  error.SetErrorStringWithFormat(
      "Platform::DisconnectRemote() is not supported by %s",
      GetPluginName().GetCString());
return error;
1022}

1024bool Platform::GetProcessInfo(lldb::pid_t pid,
                            ProcessInstanceInfo &process_info) {
// Take care of the host case so that each subclass can just call this
// function to get the host functionality.
if (IsHost())
  return Host::GetProcessInfo(pid, process_info);
return false;
1031}

1033uint32_t Platform::FindProcesses(const ProcessInstanceInfoMatch &match_info,
                               ProcessInstanceInfoList &process_infos) {
// Take care of the host case so that each subclass can just call this
// function to get the host functionality.
uint32_t match_count = 0;
if (IsHost())
  match_count = Host::FindProcesses(match_info, process_infos);
return match_count;
1041}

1043Status Platform::LaunchProcess(ProcessLaunchInfo &launch_info) {
Status error;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM(1u << 25)));
if (log)
6
←
Assuming 'log' is non-null→
7
←
Taking true branch→
  log->Printf("Platform::%s()", __FUNCTION__);

// Take care of the host case so that each subclass can just call this
// function to get the host functionality.
if (IsHost()) {
8
←
Assuming the condition is true→
9
←
Taking true branch→
  if (::getenv("LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY"))
10
←
Assuming the condition is false→
11
←
Taking false branch→
    launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY);

  if (launch_info.GetFlags().Test(eLaunchFlagLaunchInShell)) {
12
←
Taking true branch→
    const bool is_localhost = true;
    const bool will_debug = launch_info.GetFlags().Test(eLaunchFlagDebug);
    const bool first_arg_is_full_shell_command = false;
    uint32_t num_resumes = GetResumeCountForLaunchInfo(launch_info);
    if (log) {
13
←
Taking true branch→
      const FileSpec &shell = launch_info.GetShell();
      const char *shell_str = (shell) ? shell.GetPath().c_str() : "<null>";
14
←
Assuming the condition is true→
15
←
'?' condition is true→
16
←
Pointer to inner buffer of 'std::string' obtained here→
17
←
Inner buffer of 'std::string' deallocated by call to destructor→
      log->Printf(
18
←
Inner pointer of container used after re/deallocation
          "Platform::%s GetResumeCountForLaunchInfo() returned %" PRIu32"u"
          ", shell is '%s'",
          __FUNCTION__, num_resumes, shell_str);
    }

    if (!launch_info.ConvertArgumentsForLaunchingInShell(
            error, is_localhost, will_debug, first_arg_is_full_shell_command,
            num_resumes))
      return error;
  } else if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
    error = ShellExpandArguments(launch_info);
    if (error.Fail()) {
      error.SetErrorStringWithFormat("shell expansion failed (reason: %s). "
                                     "consider launching with 'process "
                                     "launch'.",
                                     error.AsCString("unknown"));
      return error;
    }
  }

  if (log)
    log->Printf("Platform::%s final launch_info resume count: %" PRIu32"u",
                __FUNCTION__, launch_info.GetResumeCount());

  error = Host::LaunchProcess(launch_info);
} else
  error.SetErrorString(
      "base lldb_private::Platform class can't launch remote processes");
return error;
1093}

1095Status Platform::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
if (IsHost())
  return Host::ShellExpandArguments(launch_info);
return Status("base lldb_private::Platform class can't expand arguments");
1099}

1101Status Platform::KillProcess(const lldb::pid_t pid) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM(1u << 25)));
if (log)
  log->Printf("Platform::%s, pid %" PRIu64"l" "u", __FUNCTION__, pid);

// Try to find a process plugin to handle this Kill request.  If we can't,
// fall back to the default OS implementation.
size_t num_debuggers = Debugger::GetNumDebuggers();
for (size_t didx = 0; didx < num_debuggers; ++didx) {
  DebuggerSP debugger = Debugger::GetDebuggerAtIndex(didx);
  lldb_private::TargetList &targets = debugger->GetTargetList();
  for (int tidx = 0; tidx < targets.GetNumTargets(); ++tidx) {
    ProcessSP process = targets.GetTargetAtIndex(tidx)->GetProcessSP();
    if (process->GetID() == pid)
      return process->Destroy(true);
  }
}

if (!IsHost()) {
  return Status(
      "base lldb_private::Platform class can't kill remote processes unless "
      "they are controlled by a process plugin");
}
Host::Kill(pid, SIGTERM15);
return Status();
1126}

1128lldb::ProcessSP
1129Platform::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
                     Target *target, // Can be nullptr, if nullptr create a
                                     // new target, else use existing one
                     Status &error) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM(1u << 25)));
if (log)
1
Assuming 'log' is null→
2
←
Taking false branch→
  log->Printf("Platform::%s entered (target %p)", __FUNCTION__,
              static_cast<void *>(target));

ProcessSP process_sp;
// Make sure we stop at the entry point
launch_info.GetFlags().Set(eLaunchFlagDebug);
// We always launch the process we are going to debug in a separate process
// group, since then we can handle ^C interrupts ourselves w/o having to
// worry about the target getting them as well.
launch_info.SetLaunchInSeparateProcessGroup(true);

// Allow any StructuredData process-bound plugins to adjust the launch info
// if needed
size_t i = 0;
bool iteration_complete = false;
// Note iteration can't simply go until a nullptr callback is returned, as it
// is valid for a plugin to not supply a filter.
auto get_filter_func = PluginManager::GetStructuredDataFilterCallbackAtIndex;
for (auto filter_callback = get_filter_func(i, iteration_complete);
4
←
Loop condition is false. Execution continues on line 1169→
     !iteration_complete;
3
←
Assuming 'iteration_complete' is not equal to 0→
     filter_callback = get_filter_func(++i, iteration_complete)) {
  if (filter_callback) {
    // Give this ProcessLaunchInfo filter a chance to adjust the launch info.
    error = (*filter_callback)(launch_info, target);
    if (!error.Success()) {
      if (log)
        log->Printf("Platform::%s() StructuredDataPlugin launch "
                    "filter failed.",
                    __FUNCTION__);
      return process_sp;
    }
  }
}

error = LaunchProcess(launch_info);
5
←
Calling 'Platform::LaunchProcess'→
if (error.Success()) {
  if (log)
    log->Printf("Platform::%s LaunchProcess() call succeeded (pid=%" PRIu64"l" "u"
                ")",
                __FUNCTION__, launch_info.GetProcessID());
  if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID0) {
    ProcessAttachInfo attach_info(launch_info);
    process_sp = Attach(attach_info, debugger, target, error);
    if (process_sp) {
      if (log)
        log->Printf("Platform::%s Attach() succeeded, Process plugin: %s",
                    __FUNCTION__, process_sp->GetPluginName().AsCString());
      launch_info.SetHijackListener(attach_info.GetHijackListener());

      // Since we attached to the process, it will think it needs to detach
      // if the process object just goes away without an explicit call to
      // Process::Kill() or Process::Detach(), so let it know to kill the
      // process if this happens.
      process_sp->SetShouldDetach(false);

      // If we didn't have any file actions, the pseudo terminal might have
      // been used where the slave side was given as the file to open for
      // stdin/out/err after we have already opened the master so we can
      // read/write stdin/out/err.
      int pty_fd = launch_info.GetPTY().ReleaseMasterFileDescriptor();
      if (pty_fd != PseudoTerminal::invalid_fd) {
        process_sp->SetSTDIOFileDescriptor(pty_fd);
      }
    } else {
      if (log)
        log->Printf("Platform::%s Attach() failed: %s", __FUNCTION__,
                    error.AsCString());
    }
  } else {
    if (log)
      log->Printf("Platform::%s LaunchProcess() returned launch_info with "
                  "invalid process id",
                  __FUNCTION__);
  }
} else {
  if (log)
    log->Printf("Platform::%s LaunchProcess() failed: %s", __FUNCTION__,
                error.AsCString());
}

return process_sp;
1216}

1218lldb::PlatformSP
1219Platform::GetPlatformForArchitecture(const ArchSpec &arch,
                                   ArchSpec *platform_arch_ptr) {
lldb::PlatformSP platform_sp;
Status error;
if (arch.IsValid())
  platform_sp = Platform::Create(arch, platform_arch_ptr, error);
return platform_sp;
1226}

1228//------------------------------------------------------------------
1229/// Lets a platform answer if it is compatible with a given
1230/// architecture and the target triple contained within.
1231//------------------------------------------------------------------
1232bool Platform::IsCompatibleArchitecture(const ArchSpec &arch,
                                      bool exact_arch_match,
                                      ArchSpec *compatible_arch_ptr) {
// If the architecture is invalid, we must answer true...
if (arch.IsValid()) {
  ArchSpec platform_arch;
  // Try for an exact architecture match first.
  if (exact_arch_match) {
    for (uint32_t arch_idx = 0;
         GetSupportedArchitectureAtIndex(arch_idx, platform_arch);
         ++arch_idx) {
      if (arch.IsExactMatch(platform_arch)) {
        if (compatible_arch_ptr)
          *compatible_arch_ptr = platform_arch;
        return true;
      }
    }
  } else {
    for (uint32_t arch_idx = 0;
         GetSupportedArchitectureAtIndex(arch_idx, platform_arch);
         ++arch_idx) {
      if (arch.IsCompatibleMatch(platform_arch)) {
        if (compatible_arch_ptr)
          *compatible_arch_ptr = platform_arch;
        return true;
      }
    }
  }
}
if (compatible_arch_ptr)
  compatible_arch_ptr->Clear();
return false;
1264}

1266Status Platform::PutFile(const FileSpec &source, const FileSpec &destination,
                       uint32_t uid, uint32_t gid) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM(1u << 25)));
if (log)
  log->Printf("[PutFile] Using block by block transfer....\n");

uint32_t source_open_options =
    File::eOpenOptionRead | File::eOpenOptionCloseOnExec;
namespace fs = llvm::sys::fs;
if (fs::is_symlink_file(source.GetPath()))
  source_open_options |= File::eOpenOptionDontFollowSymlinks;

File source_file(source, source_open_options, lldb::eFilePermissionsUserRW);
Status error;
uint32_t permissions = source_file.GetPermissions(error);
if (permissions == 0)
  permissions = lldb::eFilePermissionsFileDefault;

if (!source_file.IsValid())
  return Status("PutFile: unable to open source file");
lldb::user_id_t dest_file = OpenFile(
    destination, File::eOpenOptionCanCreate | File::eOpenOptionWrite |
                     File::eOpenOptionTruncate | File::eOpenOptionCloseOnExec,
    permissions, error);
if (log)
  log->Printf("dest_file = %" PRIu64"l" "u" "\n", dest_file);

if (error.Fail())
  return error;
if (dest_file == UINT64_MAX(18446744073709551615UL))
  return Status("unable to open target file");
lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
uint64_t offset = 0;
for (;;) {
  size_t bytes_read = buffer_sp->GetByteSize();
  error = source_file.Read(buffer_sp->GetBytes(), bytes_read);
  if (error.Fail() || bytes_read == 0)
    break;

  const uint64_t bytes_written =
      WriteFile(dest_file, offset, buffer_sp->GetBytes(), bytes_read, error);
  if (error.Fail())
    break;

  offset += bytes_written;
  if (bytes_written != bytes_read) {
    // We didn't write the correct number of bytes, so adjust the file
    // position in the source file we are reading from...
    source_file.SeekFromStart(offset);
  }
}
CloseFile(dest_file, error);

if (uid == UINT32_MAX(4294967295U) && gid == UINT32_MAX(4294967295U))
  return error;

// TODO: ChownFile?

return error;
1325}

1327Status Platform::GetFile(const FileSpec &source, const FileSpec &destination) {
Status error("unimplemented");
return error;
1330}

1332Status
1333Platform::CreateSymlink(const FileSpec &src, // The name of the link is in src
                      const FileSpec &dst) // The symlink points to dst
1335{
Status error("unimplemented");
return error;
1338}

1340bool Platform::GetFileExists(const lldb_private::FileSpec &file_spec) {
return false;
1342}

1344Status Platform::Unlink(const FileSpec &path) {
Status error("unimplemented");
return error;
1347}

1349MmapArgList Platform::GetMmapArgumentList(const ArchSpec &arch, addr_t addr,
                                        addr_t length, unsigned prot,
                                        unsigned flags, addr_t fd,
                                        addr_t offset) {
uint64_t flags_platform = 0;
if (flags & eMmapFlagsPrivate)
  flags_platform |= MAP_PRIVATE2;
if (flags & eMmapFlagsAnon)
  flags_platform |= MAP_ANON0x1000;

MmapArgList args({addr, length, prot, flags_platform, fd, offset});
return args;
1361}

1363lldb_private::Status Platform::RunShellCommand(
  const char *command, // Shouldn't be nullptr
  const FileSpec &
      working_dir, // Pass empty FileSpec to use the current working directory
  int *status_ptr, // Pass nullptr if you don't want the process exit status
  int *signo_ptr, // Pass nullptr if you don't want the signal that caused the
                  // process to exit
  std::string
      *command_output, // Pass nullptr if you don't want the command output
  const Timeout<std::micro> &timeout) {
if (IsHost())
  return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
                               command_output, timeout);
else
  return Status("unimplemented");
1378}

1380bool Platform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
                          uint64_t &high) {
if (!IsHost())
  return false;
auto Result = llvm::sys::fs::md5_contents(file_spec.GetPath());
if (!Result)
  return false;
std::tie(high, low) = Result->words();
return true;
1389}

1391void Platform::SetLocalCacheDirectory(const char *local) {
m_local_cache_directory.assign(local);
1393}

1395const char *Platform::GetLocalCacheDirectory() {
return m_local_cache_directory.c_str();
1397}

1399static constexpr OptionDefinition g_rsync_option_table[] = {
  {LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "rsync", 'r', OptionParser::eNoArgument, nullptr,
   {}, 0, eArgTypeNone, "Enable rsync."},
  {LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "rsync-opts", 'R',
   OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
   "Platform-specific options required for rsync to work."},
  {LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "rsync-prefix", 'P',
   OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
   "Platform-specific rsync prefix put before the remote path."},
  {LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "ignore-remote-hostname", 'i',
   OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone,
   "Do not automatically fill in the remote hostname when composing the "
   "rsync command."},
1412};

1414static constexpr OptionDefinition g_ssh_option_table[] = {
  {LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "ssh", 's', OptionParser::eNoArgument, nullptr,
   {}, 0, eArgTypeNone, "Enable SSH."},
  {LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "ssh-opts", 'S', OptionParser::eRequiredArgument,
   nullptr, {}, 0, eArgTypeCommandName,
   "Platform-specific options required for SSH to work."},
1420};

1422static constexpr OptionDefinition g_caching_option_table[] = {
  {LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "local-cache-dir", 'c',
   OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypePath,
   "Path in which to store local copies of files."},
1426};

1428llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() {
return llvm::makeArrayRef(g_rsync_option_table);
1430}

1432void OptionGroupPlatformRSync::OptionParsingStarting(
  ExecutionContext *execution_context) {
m_rsync = false;
m_rsync_opts.clear();
m_rsync_prefix.clear();
m_ignores_remote_hostname = false;
1438}

1440lldb_private::Status
1441OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
                                       llvm::StringRef option_arg,
                                       ExecutionContext *execution_context) {
Status error;
char short_option = (char)GetDefinitions()[option_idx].short_option;
switch (short_option) {
case 'r':
  m_rsync = true;
  break;

case 'R':
  m_rsync_opts.assign(option_arg);
  break;

case 'P':
  m_rsync_prefix.assign(option_arg);
  break;

case 'i':
  m_ignores_remote_hostname = true;
  break;

default:
  error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
  break;
}

return error;
1469}

1471lldb::BreakpointSP
1472Platform::SetThreadCreationBreakpoint(lldb_private::Target &target) {
return lldb::BreakpointSP();
1474}

1476llvm::ArrayRef<OptionDefinition> OptionGroupPlatformSSH::GetDefinitions() {
return llvm::makeArrayRef(g_ssh_option_table);
1478}

1480void OptionGroupPlatformSSH::OptionParsingStarting(
  ExecutionContext *execution_context) {
m_ssh = false;
m_ssh_opts.clear();
1484}

1486lldb_private::Status
1487OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
                                     llvm::StringRef option_arg,
                                     ExecutionContext *execution_context) {
Status error;
char short_option = (char)GetDefinitions()[option_idx].short_option;
switch (short_option) {
case 's':
  m_ssh = true;
  break;

case 'S':
  m_ssh_opts.assign(option_arg);
  break;

default:
  error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
  break;
}

return error;
1507}

1509llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() {
return llvm::makeArrayRef(g_caching_option_table);
1511}

1513void OptionGroupPlatformCaching::OptionParsingStarting(
  ExecutionContext *execution_context) {
m_cache_dir.clear();
1516}

1518lldb_private::Status OptionGroupPlatformCaching::SetOptionValue(
  uint32_t option_idx, llvm::StringRef option_arg,
  ExecutionContext *execution_context) {
Status error;
char short_option = (char)GetDefinitions()[option_idx].short_option;
switch (short_option) {
case 'c':
  m_cache_dir.assign(option_arg);
  break;

default:
  error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
  break;
}

return error;
1534}

1536Environment Platform::GetEnvironment() { return Environment(); }

1538const std::vector<ConstString> &Platform::GetTrapHandlerSymbolNames() {
if (!m_calculated_trap_handlers) {
  std::lock_guard<std::mutex> guard(m_mutex);
  if (!m_calculated_trap_handlers) {
    CalculateTrapHandlerSymbolNames();
    m_calculated_trap_handlers = true;
  }
}
return m_trap_handlers;
1547}

1549Status Platform::GetCachedExecutable(
  ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
  const FileSpecList *module_search_paths_ptr, Platform &remote_platform) {
const auto platform_spec = module_spec.GetFileSpec();
const auto error = LoadCachedExecutable(
    module_spec, module_sp, module_search_paths_ptr, remote_platform);
if (error.Success()) {
  module_spec.GetFileSpec() = module_sp->GetFileSpec();
  module_spec.GetPlatformFileSpec() = platform_spec;
}

return error;
1561}

1563Status Platform::LoadCachedExecutable(
  const ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
  const FileSpecList *module_search_paths_ptr, Platform &remote_platform) {
return GetRemoteSharedModule(module_spec, nullptr, module_sp,
                             [&](const ModuleSpec &spec) {
                               return remote_platform.ResolveExecutable(
                                   spec, module_sp, module_search_paths_ptr);
                             },
                             nullptr);
1572}

1574Status Platform::GetRemoteSharedModule(const ModuleSpec &module_spec,
                                     Process *process,
                                     lldb::ModuleSP &module_sp,
                                     const ModuleResolver &module_resolver,
                                     bool *did_create_ptr) {
// Get module information from a target.
ModuleSpec resolved_module_spec;
bool got_module_spec = false;
if (process) {
  // Try to get module information from the process
  if (process->GetModuleSpec(module_spec.GetFileSpec(),
                             module_spec.GetArchitecture(),
                             resolved_module_spec)) {
    if (module_spec.GetUUID().IsValid() == false ||
        module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
      got_module_spec = true;
    }
  }
}

if (module_spec.GetArchitecture().IsValid() == false) {
  Status error;
  // No valid architecture was specified, ask the platform for the
  // architectures that we should be using (in the correct order) and see if
  // we can find a match that way
  ModuleSpec arch_module_spec(module_spec);
  for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
           idx, arch_module_spec.GetArchitecture());
       ++idx) {
    error = ModuleList::GetSharedModule(arch_module_spec, module_sp, nullptr,
                                        nullptr, nullptr);
    // Did we find an executable using one of the
    if (error.Success() && module_sp)
      break;
  }
  if (module_sp)
    got_module_spec = true;
}

if (!got_module_spec) {
  // Get module information from a target.
  if (!GetModuleSpec(module_spec.GetFileSpec(), module_spec.GetArchitecture(),
                     resolved_module_spec)) {
    if (module_spec.GetUUID().IsValid() == false ||
        module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
      return module_resolver(module_spec);
    }
  }
}

// If we are looking for a specific UUID, make sure resolved_module_spec has
// the same one before we search.
if (module_spec.GetUUID().IsValid()) {
  resolved_module_spec.GetUUID() = module_spec.GetUUID();
}

// Trying to find a module by UUID on local file system.
const auto error = module_resolver(resolved_module_spec);
if (error.Fail()) {
  if (GetCachedSharedModule(resolved_module_spec, module_sp, did_create_ptr))
    return Status();
}

return error;
1638}

1640bool Platform::GetCachedSharedModule(const ModuleSpec &module_spec,
                                   lldb::ModuleSP &module_sp,
                                   bool *did_create_ptr) {
if (IsHost() || !GetGlobalPlatformProperties()->GetUseModuleCache() ||
    !GetGlobalPlatformProperties()->GetModuleCacheDirectory())
  return false;

Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM(1u << 25));

// Check local cache for a module.
auto error = m_module_cache->GetAndPut(
    GetModuleCacheRoot(), GetCacheHostname(), module_spec,
    [this](const ModuleSpec &module_spec,
           const FileSpec &tmp_download_file_spec) {
      return DownloadModuleSlice(
          module_spec.GetFileSpec(), module_spec.GetObjectOffset(),
          module_spec.GetObjectSize(), tmp_download_file_spec);

    },
    [this](const ModuleSP &module_sp,
           const FileSpec &tmp_download_file_spec) {
      return DownloadSymbolFile(module_sp, tmp_download_file_spec);
    },
    module_sp, did_create_ptr);
if (error.Success())
  return true;

if (log)
  log->Printf("Platform::%s - module %s not found in local cache: %s",
              __FUNCTION__, module_spec.GetUUID().GetAsString().c_str(),
              error.AsCString());
return false;
1672}

1674Status Platform::DownloadModuleSlice(const FileSpec &src_file_spec,
                                   const uint64_t src_offset,
                                   const uint64_t src_size,
                                   const FileSpec &dst_file_spec) {
Status error;

std::error_code EC;
llvm::raw_fd_ostream dst(dst_file_spec.GetPath(), EC, llvm::sys::fs::F_None);
if (EC) {
  error.SetErrorStringWithFormat("unable to open destination file: %s",
                                 dst_file_spec.GetPath().c_str());
  return error;
}

auto src_fd = OpenFile(src_file_spec, File::eOpenOptionRead,
                       lldb::eFilePermissionsFileDefault, error);

if (error.Fail()) {
  error.SetErrorStringWithFormat("unable to open source file: %s",
                                 error.AsCString());
  return error;
}

std::vector<char> buffer(1024);
auto offset = src_offset;
uint64_t total_bytes_read = 0;
while (total_bytes_read < src_size) {
  const auto to_read = std::min(static_cast<uint64_t>(buffer.size()),
                                src_size - total_bytes_read);
  const uint64_t n_read =
      ReadFile(src_fd, offset, &buffer[0], to_read, error);
  if (error.Fail())
    break;
  if (n_read == 0) {
    error.SetErrorString("read 0 bytes");
    break;
  }
  offset += n_read;
  total_bytes_read += n_read;
  dst.write(&buffer[0], n_read);
}

Status close_error;
CloseFile(src_fd, close_error); // Ignoring close error.

return error;
1720}

1722Status Platform::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
                                  const FileSpec &dst_file_spec) {
return Status(
    "Symbol file downloading not supported by the default platform.");
1726}

1728FileSpec Platform::GetModuleCacheRoot() {
auto dir_spec = GetGlobalPlatformProperties()->GetModuleCacheDirectory();
dir_spec.AppendPathComponent(GetName().AsCString());
return dir_spec;
1732}

1734const char *Platform::GetCacheHostname() { return GetHostname(); }

1736const UnixSignalsSP &Platform::GetRemoteUnixSignals() {
static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>();
return s_default_unix_signals_sp;
1739}

1741const UnixSignalsSP &Platform::GetUnixSignals() {
if (IsHost())
  return Host::GetUnixSignals();
return GetRemoteUnixSignals();
1745}

1747uint32_t Platform::LoadImage(lldb_private::Process *process,
                           const lldb_private::FileSpec &local_file,
                           const lldb_private::FileSpec &remote_file,
                           lldb_private::Status &error) {
if (local_file && remote_file) {
  // Both local and remote file was specified. Install the local file to the
  // given location.
  if (IsRemote() || local_file != remote_file) {
    error = Install(local_file, remote_file);
    if (error.Fail())
      return LLDB_INVALID_IMAGE_TOKEN(4294967295U);
  }
  return DoLoadImage(process, remote_file, nullptr, error);
}

if (local_file) {
  // Only local file was specified. Install it to the current working
  // directory.
  FileSpec target_file = GetWorkingDirectory();
  target_file.AppendPathComponent(local_file.GetFilename().AsCString());
  if (IsRemote() || local_file != target_file) {
    error = Install(local_file, target_file);
    if (error.Fail())
      return LLDB_INVALID_IMAGE_TOKEN(4294967295U);
  }
  return DoLoadImage(process, target_file, nullptr, error);
} 

if (remote_file) {
  // Only remote file was specified so we don't have to do any copying
  return DoLoadImage(process, remote_file, nullptr, error);
}

error.SetErrorString("Neither local nor remote file was specified");
return LLDB_INVALID_IMAGE_TOKEN(4294967295U);
1782}

1784uint32_t Platform::DoLoadImage(lldb_private::Process *process,
                             const lldb_private::FileSpec &remote_file,
                             const std::vector<std::string> *paths,
                             lldb_private::Status &error,
                             lldb_private::FileSpec *loaded_image) {
error.SetErrorString("LoadImage is not supported on the current platform");
return LLDB_INVALID_IMAGE_TOKEN(4294967295U);
1791}

1793uint32_t Platform::LoadImageUsingPaths(lldb_private::Process *process,
                             const lldb_private::FileSpec &remote_filename,
                             const std::vector<std::string> &paths,
                             lldb_private::Status &error,
                             lldb_private::FileSpec *loaded_path)
1798{
FileSpec file_to_use;
if (remote_filename.IsAbsolute())
  file_to_use = FileSpec(remote_filename.GetFilename().GetStringRef(), 
                             false, 
                             remote_filename.GetPathStyle());
else
  file_to_use = remote_filename;
  
return DoLoadImage(process, file_to_use, &paths, error, loaded_path);
1808}

1810Status Platform::UnloadImage(lldb_private::Process *process,
                           uint32_t image_token) {
return Status("UnloadImage is not supported on the current platform");
1813}

1815lldb::ProcessSP Platform::ConnectProcess(llvm::StringRef connect_url,
                                       llvm::StringRef plugin_name,
                                       lldb_private::Debugger &debugger,
                                       lldb_private::Target *target,
                                       lldb_private::Status &error) {
error.Clear();

if (!target) {
  ArchSpec arch;
  if (target && target->GetArchitecture().IsValid())
    arch = target->GetArchitecture();
  else
    arch = Target::GetDefaultArchitecture();

  const char *triple = "";
  if (arch.IsValid())
    triple = arch.GetTriple().getTriple().c_str();

  TargetSP new_target_sp;
  error = debugger.GetTargetList().CreateTarget(
      debugger, "", triple, eLoadDependentsNo, nullptr, new_target_sp);
  target = new_target_sp.get();
}

if (!target || error.Fail())
  return nullptr;

debugger.GetTargetList().SetSelectedTarget(target);

lldb::ProcessSP process_sp =
    target->CreateProcess(debugger.GetListener(), plugin_name, nullptr);
if (!process_sp)
  return nullptr;

error =
    process_sp->ConnectRemote(debugger.GetOutputFile().get(), connect_url);
if (error.Fail())
  return nullptr;

return process_sp;
1855}

1857size_t Platform::ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
                                         lldb_private::Status &error) {
error.Clear();
return 0;
1861}

1863size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target,
                                               BreakpointSite *bp_site) {
ArchSpec arch = target.GetArchitecture();
const uint8_t *trap_opcode = nullptr;
size_t trap_opcode_size = 0;

switch (arch.GetMachine()) {
case llvm::Triple::aarch64: {
  static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4};
  trap_opcode = g_aarch64_opcode;
  trap_opcode_size = sizeof(g_aarch64_opcode);
} break;

// TODO: support big-endian arm and thumb trap codes.
case llvm::Triple::arm: {
  // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
  // linux kernel does otherwise.
  static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
  static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};

  lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
  AddressClass addr_class = AddressClass::eUnknown;

  if (bp_loc_sp) {
    addr_class = bp_loc_sp->GetAddress().GetAddressClass();
    if (addr_class == AddressClass::eUnknown &&
        (bp_loc_sp->GetAddress().GetFileAddress() & 1))
      addr_class = AddressClass::eCodeAlternateISA;
  }

  if (addr_class == AddressClass::eCodeAlternateISA) {
    trap_opcode = g_thumb_breakpoint_opcode;
    trap_opcode_size = sizeof(g_thumb_breakpoint_opcode);
  } else {
    trap_opcode = g_arm_breakpoint_opcode;
    trap_opcode_size = sizeof(g_arm_breakpoint_opcode);
  }
} break;

case llvm::Triple::mips:
case llvm::Triple::mips64: {
  static const uint8_t g_hex_opcode[] = {0x00, 0x00, 0x00, 0x0d};
  trap_opcode = g_hex_opcode;
  trap_opcode_size = sizeof(g_hex_opcode);
} break;

case llvm::Triple::mipsel:
case llvm::Triple::mips64el: {
  static const uint8_t g_hex_opcode[] = {0x0d, 0x00, 0x00, 0x00};
  trap_opcode = g_hex_opcode;
  trap_opcode_size = sizeof(g_hex_opcode);
} break;

case llvm::Triple::systemz: {
  static const uint8_t g_hex_opcode[] = {0x00, 0x01};
  trap_opcode = g_hex_opcode;
  trap_opcode_size = sizeof(g_hex_opcode);
} break;

case llvm::Triple::hexagon: {
  static const uint8_t g_hex_opcode[] = {0x0c, 0xdb, 0x00, 0x54};
  trap_opcode = g_hex_opcode;
  trap_opcode_size = sizeof(g_hex_opcode);
} break;

case llvm::Triple::ppc:
case llvm::Triple::ppc64: {
  static const uint8_t g_ppc_opcode[] = {0x7f, 0xe0, 0x00, 0x08};
  trap_opcode = g_ppc_opcode;
  trap_opcode_size = sizeof(g_ppc_opcode);
} break;

case llvm::Triple::ppc64le: {
  static const uint8_t g_ppc64le_opcode[] = {0x08, 0x00, 0xe0, 0x7f}; // trap
  trap_opcode = g_ppc64le_opcode;
  trap_opcode_size = sizeof(g_ppc64le_opcode);
} break;

case llvm::Triple::x86:
case llvm::Triple::x86_64: {
  static const uint8_t g_i386_opcode[] = {0xCC};
  trap_opcode = g_i386_opcode;
  trap_opcode_size = sizeof(g_i386_opcode);
} break;

default:
  llvm_unreachable(::llvm::llvm_unreachable_internal("Unhandled architecture in Platform::GetSoftwareBreakpointTrapOpcode"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Target/Platform.cpp"
, 1950)
      "Unhandled architecture in Platform::GetSoftwareBreakpointTrapOpcode")::llvm::llvm_unreachable_internal("Unhandled architecture in Platform::GetSoftwareBreakpointTrapOpcode"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Target/Platform.cpp"
, 1950);
}

assert(bp_site)((bp_site) ? static_cast<void> (0) : __assert_fail ("bp_site"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Target/Platform.cpp"
, 1953, __PRETTY_FUNCTION__));
if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size))
  return trap_opcode_size;

return 0;
1958}