| //===-- PlatformAppleSimulator.cpp ------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "PlatformAppleSimulator.h" |
| |
| // C Includes |
| #if defined(__APPLE__) |
| #include <dlfcn.h> |
| #endif |
| |
| // C++ Includes |
| #include <mutex> |
| #include <thread> |
| // Other libraries and framework includes |
| // Project includes |
| #include "lldb/Core/Error.h" |
| #include "lldb/Core/StreamString.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Utility/LLDBAssert.h" |
| #include "lldb/Utility/PseudoTerminal.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| #if !defined(__APPLE__) |
| #define UNSUPPORTED_ERROR ("Apple simulators aren't supported on this platform") |
| #endif |
| |
| //------------------------------------------------------------------ |
| // Static Functions |
| //------------------------------------------------------------------ |
| void |
| PlatformAppleSimulator::Initialize () |
| { |
| PlatformDarwin::Initialize (); |
| } |
| |
| void |
| PlatformAppleSimulator::Terminate () |
| { |
| PlatformDarwin::Terminate (); |
| } |
| |
| //------------------------------------------------------------------ |
| /// Default Constructor |
| //------------------------------------------------------------------ |
| PlatformAppleSimulator::PlatformAppleSimulator () : |
| PlatformDarwin (true), |
| m_core_simulator_framework_path() |
| { |
| } |
| |
| //------------------------------------------------------------------ |
| /// Destructor. |
| /// |
| /// The destructor is virtual since this class is designed to be |
| /// inherited from by the plug-in instance. |
| //------------------------------------------------------------------ |
| PlatformAppleSimulator::~PlatformAppleSimulator() |
| { |
| } |
| |
| lldb_private::Error |
| PlatformAppleSimulator::LaunchProcess (lldb_private::ProcessLaunchInfo &launch_info) |
| { |
| #if defined(__APPLE__) |
| LoadCoreSimulator(); |
| CoreSimulatorSupport::Device device(GetSimulatorDevice()); |
| |
| if (device.GetState() != CoreSimulatorSupport::Device::State::Booted) |
| { |
| Error boot_err; |
| device.Boot(boot_err); |
| if (boot_err.Fail()) |
| return boot_err; |
| } |
| |
| auto spawned = device.Spawn(launch_info); |
| |
| if (spawned) |
| { |
| launch_info.SetProcessID(spawned.GetPID()); |
| return Error(); |
| } |
| else |
| return spawned.GetError(); |
| #else |
| Error err; |
| err.SetErrorString(UNSUPPORTED_ERROR); |
| return err; |
| #endif |
| } |
| |
| void |
| PlatformAppleSimulator::GetStatus (Stream &strm) |
| { |
| #if defined(__APPLE__) |
| // This will get called by subclasses, so just output status on the |
| // current simulator |
| PlatformAppleSimulator::LoadCoreSimulator(); |
| |
| CoreSimulatorSupport::DeviceSet devices = CoreSimulatorSupport::DeviceSet::GetAvailableDevices(); |
| const size_t num_devices = devices.GetNumDevices(); |
| if (num_devices) |
| { |
| strm.Printf("Available devices:\n"); |
| for (size_t i=0; i<num_devices; ++i) |
| { |
| CoreSimulatorSupport::Device device = devices.GetDeviceAtIndex(i); |
| strm.Printf(" %s: %s\n", device.GetUDID().c_str(), device.GetName().c_str()); |
| } |
| |
| if (m_device.hasValue() && m_device->operator bool()) |
| { |
| strm.Printf("Current device: %s: %s", m_device->GetUDID().c_str(), m_device->GetName().c_str()); |
| if (m_device->GetState() == CoreSimulatorSupport::Device::State::Booted) |
| { |
| strm.Printf(" state = booted"); |
| } |
| strm.Printf("\nType \"platform connect <ARG>\" where <ARG> is a device UDID or a device name to disconnect and connect to a different device.\n"); |
| |
| } |
| else |
| { |
| strm.Printf("No current device is selected, \"platform connect <ARG>\" where <ARG> is a device UDID or a device name to connect to a specific device.\n"); |
| } |
| |
| } |
| else |
| { |
| strm.Printf("No devices are available.\n"); |
| } |
| #else |
| strm.Printf(UNSUPPORTED_ERROR); |
| #endif |
| } |
| |
| Error |
| PlatformAppleSimulator::ConnectRemote (Args& args) |
| { |
| #if defined(__APPLE__) |
| Error error; |
| if (args.GetArgumentCount() == 1) |
| { |
| if (m_device) |
| DisconnectRemote (); |
| PlatformAppleSimulator::LoadCoreSimulator(); |
| const char *arg_cstr = args.GetArgumentAtIndex(0); |
| if (arg_cstr) |
| { |
| std::string arg_str(arg_cstr); |
| CoreSimulatorSupport::DeviceSet devices = CoreSimulatorSupport::DeviceSet::GetAvailableDevices(); |
| devices.ForEach([this, &arg_str](const CoreSimulatorSupport::Device &device) -> bool { |
| if (arg_str == device.GetUDID() || arg_str == device.GetName()) |
| { |
| m_device = device; |
| return false; // Stop iterating |
| } |
| else |
| { |
| return true; // Keep iterating |
| } |
| }); |
| if (!m_device) |
| error.SetErrorStringWithFormat("no device with UDID or name '%s' was found", arg_cstr); |
| } |
| } |
| else |
| { |
| error.SetErrorString("this command take a single UDID argument of the device you want to connect to."); |
| } |
| return error; |
| #else |
| Error err; |
| err.SetErrorString(UNSUPPORTED_ERROR); |
| return err; |
| #endif |
| } |
| |
| Error |
| PlatformAppleSimulator::DisconnectRemote () |
| { |
| #if defined(__APPLE__) |
| m_device.reset(); |
| return Error(); |
| #else |
| Error err; |
| err.SetErrorString(UNSUPPORTED_ERROR); |
| return err; |
| #endif |
| } |
| |
| |
| lldb::ProcessSP |
| PlatformAppleSimulator::DebugProcess (ProcessLaunchInfo &launch_info, |
| Debugger &debugger, |
| Target *target, // Can be NULL, if NULL create a new target, else use existing one |
| Error &error) |
| { |
| #if defined(__APPLE__) |
| 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); |
| |
| error = LaunchProcess (launch_info); |
| if (error.Success()) |
| { |
| if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) |
| { |
| ProcessAttachInfo attach_info (launch_info); |
| process_sp = Attach (attach_info, debugger, target, error); |
| if (process_sp) |
| { |
| 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 != lldb_utility::PseudoTerminal::invalid_fd) |
| { |
| process_sp->SetSTDIOFileDescriptor(pty_fd); |
| } |
| } |
| } |
| } |
| |
| return process_sp; |
| #else |
| return ProcessSP(); |
| #endif |
| } |
| |
| FileSpec |
| PlatformAppleSimulator::GetCoreSimulatorPath() |
| { |
| #if defined(__APPLE__) |
| std::lock_guard<std::mutex> guard(m_mutex); |
| if (!m_core_simulator_framework_path.hasValue()) |
| { |
| const char *developer_dir = GetDeveloperDirectory(); |
| if (developer_dir) |
| { |
| StreamString cs_path; |
| cs_path.Printf("%s/Library/PrivateFrameworks/CoreSimulator.framework/CoreSimulator", developer_dir); |
| const bool resolve_path = true; |
| m_core_simulator_framework_path = FileSpec(cs_path.GetData(), resolve_path); |
| } |
| } |
| |
| return m_core_simulator_framework_path.getValue(); |
| #else |
| return FileSpec(); |
| #endif |
| } |
| |
| void |
| PlatformAppleSimulator::LoadCoreSimulator () |
| { |
| #if defined(__APPLE__) |
| static std::once_flag g_load_core_sim_flag; |
| std::call_once(g_load_core_sim_flag, [this] { |
| const std::string core_sim_path(GetCoreSimulatorPath().GetPath()); |
| if (core_sim_path.size()) |
| dlopen(core_sim_path.c_str(), RTLD_LAZY); |
| }); |
| #endif |
| } |
| |
| #if defined(__APPLE__) |
| CoreSimulatorSupport::Device |
| PlatformAppleSimulator::GetSimulatorDevice () |
| { |
| if (!m_device.hasValue()) |
| { |
| const CoreSimulatorSupport::DeviceType::ProductFamilyID dev_id = CoreSimulatorSupport::DeviceType::ProductFamilyID::iPhone; |
| m_device = CoreSimulatorSupport::DeviceSet::GetAvailableDevices().GetFanciest(dev_id); |
| } |
| |
| if (m_device.hasValue()) |
| return m_device.getValue(); |
| else |
| return CoreSimulatorSupport::Device(); |
| } |
| #endif |
| |
