b9a01b3990
more of the local path, platform path, associated symbol file, UUID, arch, object name and object offset. This allows many of the calls that were GetSharedModule to reduce the number of arguments that were used in a call to these functions. It also allows a module to be created with a ModuleSpec which allows many things to be specified prior to any accessors being called on the Module class itself. I was running into problems when adding support for "target symbol add" where you can specify a stand alone debug info file after debugging has started where I needed to specify the associated symbol file path and if I waited until after construction, the wrong symbol file had already been located. By using the ModuleSpec it allows us to construct a module with as little or as much information as needed and not have to change the parameter list. llvm-svn: 151476
375 lines
12 KiB
C++
375 lines
12 KiB
C++
//===-- PlatformiOSSimulator.cpp -----------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "PlatformiOSSimulator.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Breakpoint/BreakpointLocation.h"
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/Core/Error.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ModuleList.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/StreamString.h"
|
|
#include "lldb/Host/FileSpec.h"
|
|
#include "lldb/Host/Host.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Target.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//------------------------------------------------------------------
|
|
// Static Variables
|
|
//------------------------------------------------------------------
|
|
static uint32_t g_initialize_count = 0;
|
|
|
|
//------------------------------------------------------------------
|
|
// Static Functions
|
|
//------------------------------------------------------------------
|
|
void
|
|
PlatformiOSSimulator::Initialize ()
|
|
{
|
|
if (g_initialize_count++ == 0)
|
|
{
|
|
PluginManager::RegisterPlugin (PlatformiOSSimulator::GetShortPluginNameStatic(),
|
|
PlatformiOSSimulator::GetDescriptionStatic(),
|
|
PlatformiOSSimulator::CreateInstance);
|
|
}
|
|
}
|
|
|
|
void
|
|
PlatformiOSSimulator::Terminate ()
|
|
{
|
|
if (g_initialize_count > 0)
|
|
{
|
|
if (--g_initialize_count == 0)
|
|
{
|
|
PluginManager::UnregisterPlugin (PlatformiOSSimulator::CreateInstance);
|
|
}
|
|
}
|
|
}
|
|
|
|
Platform*
|
|
PlatformiOSSimulator::CreateInstance ()
|
|
{
|
|
return new PlatformiOSSimulator ();
|
|
}
|
|
|
|
|
|
const char *
|
|
PlatformiOSSimulator::GetPluginNameStatic ()
|
|
{
|
|
return "PlatformiOSSimulator";
|
|
}
|
|
|
|
const char *
|
|
PlatformiOSSimulator::GetShortPluginNameStatic()
|
|
{
|
|
return "ios-simulator";
|
|
}
|
|
|
|
const char *
|
|
PlatformiOSSimulator::GetDescriptionStatic()
|
|
{
|
|
return "iOS simulator platform plug-in.";
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
/// Default Constructor
|
|
//------------------------------------------------------------------
|
|
PlatformiOSSimulator::PlatformiOSSimulator () :
|
|
PlatformDarwin (false),
|
|
m_sdk_directory ()
|
|
{
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
/// Destructor.
|
|
///
|
|
/// The destructor is virtual since this class is designed to be
|
|
/// inherited from by the plug-in instance.
|
|
//------------------------------------------------------------------
|
|
PlatformiOSSimulator::~PlatformiOSSimulator()
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
PlatformiOSSimulator::GetStatus (Stream &strm)
|
|
{
|
|
Platform::GetStatus (strm);
|
|
const char *sdk_directory = GetSDKDirectory();
|
|
if (sdk_directory)
|
|
strm.Printf (" SDK Path: \"%s\"\n", sdk_directory);
|
|
else
|
|
strm.PutCString (" SDK Path: error: unable to locate SDK\n");
|
|
}
|
|
|
|
|
|
Error
|
|
PlatformiOSSimulator::ResolveExecutable (const FileSpec &exe_file,
|
|
const ArchSpec &exe_arch,
|
|
lldb::ModuleSP &exe_module_sp,
|
|
const FileSpecList *module_search_paths_ptr)
|
|
{
|
|
Error error;
|
|
// Nothing special to do here, just use the actual file and architecture
|
|
|
|
FileSpec resolved_exe_file (exe_file);
|
|
|
|
// If we have "ls" as the exe_file, resolve the executable loation based on
|
|
// the current path variables
|
|
// TODO: resolve bare executables in the Platform SDK
|
|
// if (!resolved_exe_file.Exists())
|
|
// resolved_exe_file.ResolveExecutableLocation ();
|
|
|
|
// Resolve any executable within a bundle on MacOSX
|
|
// TODO: verify that this handles shallow bundles, if not then implement one ourselves
|
|
Host::ResolveExecutableInBundle (resolved_exe_file);
|
|
|
|
if (resolved_exe_file.Exists())
|
|
{
|
|
ModuleSpec module_spec(resolved_exe_file, exe_arch);
|
|
if (exe_arch.IsValid())
|
|
{
|
|
error = ModuleList::GetSharedModule (module_spec,
|
|
exe_module_sp,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
|
|
if (exe_module_sp->GetObjectFile())
|
|
return error;
|
|
exe_module_sp.reset();
|
|
}
|
|
// No valid architecture was specified or the exact ARM slice wasn't
|
|
// found so 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
|
|
StreamString arch_names;
|
|
ArchSpec platform_arch;
|
|
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, module_spec.GetArchitecture()); ++idx)
|
|
{
|
|
|
|
error = ModuleList::GetSharedModule (module_spec,
|
|
exe_module_sp,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
// Did we find an executable using one of the
|
|
if (error.Success())
|
|
{
|
|
if (exe_module_sp && exe_module_sp->GetObjectFile())
|
|
break;
|
|
else
|
|
error.SetErrorToGenericError();
|
|
}
|
|
|
|
if (idx > 0)
|
|
arch_names.PutCString (", ");
|
|
arch_names.PutCString (platform_arch.GetArchitectureName());
|
|
}
|
|
|
|
if (error.Fail() || !exe_module_sp)
|
|
{
|
|
error.SetErrorStringWithFormat ("'%s%s%s' doesn't contain any '%s' platform architectures: %s",
|
|
exe_file.GetDirectory().AsCString(""),
|
|
exe_file.GetDirectory() ? "/" : "",
|
|
exe_file.GetFilename().AsCString(""),
|
|
GetShortPluginName(),
|
|
arch_names.GetString().c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorStringWithFormat ("'%s%s%s' does not exist",
|
|
exe_file.GetDirectory().AsCString(""),
|
|
exe_file.GetDirectory() ? "/" : "",
|
|
exe_file.GetFilename().AsCString(""));
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
static FileSpec::EnumerateDirectoryResult
|
|
EnumerateDirectoryCallback (void *baton, FileSpec::FileType file_type, const FileSpec &file_spec)
|
|
{
|
|
if (file_type == FileSpec::eFileTypeDirectory)
|
|
{
|
|
const char *filename = file_spec.GetFilename().GetCString();
|
|
if (filename && strncmp(filename, "iPhoneSimulator", strlen ("iPhoneSimulator")) == 0)
|
|
{
|
|
::snprintf ((char *)baton, PATH_MAX, "%s", filename);
|
|
return FileSpec::eEnumerateDirectoryResultQuit;
|
|
}
|
|
}
|
|
return FileSpec::eEnumerateDirectoryResultNext;
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
PlatformiOSSimulator::GetSDKDirectory()
|
|
{
|
|
if (m_sdk_directory.empty())
|
|
{
|
|
const char *developer_dir = GetDeveloperDirectory();
|
|
if (developer_dir)
|
|
{
|
|
char sdks_directory[PATH_MAX];
|
|
char sdk_dirname[PATH_MAX];
|
|
sdk_dirname[0] = '\0';
|
|
snprintf (sdks_directory,
|
|
sizeof(sdks_directory),
|
|
"%s/Platforms/iPhoneSimulator.platform/Developer/SDKs",
|
|
developer_dir);
|
|
FileSpec simulator_sdk_spec;
|
|
bool find_directories = true;
|
|
bool find_files = false;
|
|
bool find_other = false;
|
|
FileSpec::EnumerateDirectory (sdks_directory,
|
|
find_directories,
|
|
find_files,
|
|
find_other,
|
|
EnumerateDirectoryCallback,
|
|
sdk_dirname);
|
|
|
|
if (sdk_dirname[0])
|
|
{
|
|
m_sdk_directory = sdks_directory;
|
|
m_sdk_directory.append (1, '/');
|
|
m_sdk_directory.append (sdk_dirname);
|
|
return m_sdk_directory.c_str();
|
|
}
|
|
}
|
|
// Assign a single NULL character so we know we tried to find the device
|
|
// support directory and we don't keep trying to find it over and over.
|
|
m_sdk_directory.assign (1, '\0');
|
|
}
|
|
|
|
// We should have put a single NULL character into m_sdk_directory
|
|
// or it should have a valid path if the code gets here
|
|
assert (m_sdk_directory.empty() == false);
|
|
if (m_sdk_directory[0])
|
|
return m_sdk_directory.c_str();
|
|
return NULL;
|
|
}
|
|
|
|
Error
|
|
PlatformiOSSimulator::GetFile (const FileSpec &platform_file,
|
|
const UUID *uuid_ptr,
|
|
FileSpec &local_file)
|
|
{
|
|
Error error;
|
|
char platform_file_path[PATH_MAX];
|
|
if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path)))
|
|
{
|
|
char resolved_path[PATH_MAX];
|
|
|
|
const char * sdk_dir = GetSDKDirectory();
|
|
if (sdk_dir)
|
|
{
|
|
::snprintf (resolved_path,
|
|
sizeof(resolved_path),
|
|
"%s/%s",
|
|
sdk_dir,
|
|
platform_file_path);
|
|
|
|
// First try in the SDK and see if the file is in there
|
|
local_file.SetFile(resolved_path, true);
|
|
if (local_file.Exists())
|
|
return error;
|
|
|
|
// Else fall back to the actual path itself
|
|
local_file.SetFile(platform_file_path, true);
|
|
if (local_file.Exists())
|
|
return error;
|
|
|
|
}
|
|
error.SetErrorStringWithFormat ("unable to locate a platform file for '%s' in platform '%s'",
|
|
platform_file_path,
|
|
GetPluginName());
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("invalid platform file argument");
|
|
}
|
|
return error;
|
|
}
|
|
|
|
Error
|
|
PlatformiOSSimulator::GetSharedModule (const ModuleSpec &module_spec,
|
|
ModuleSP &module_sp,
|
|
const FileSpecList *module_search_paths_ptr,
|
|
ModuleSP *old_module_sp_ptr,
|
|
bool *did_create_ptr)
|
|
{
|
|
// For iOS, the SDK files are all cached locally on the host
|
|
// system. So first we ask for the file in the cached SDK,
|
|
// then we attempt to get a shared module for the right architecture
|
|
// with the right UUID.
|
|
Error error;
|
|
FileSpec local_file;
|
|
const FileSpec &platform_file = module_spec.GetFileSpec();
|
|
error = GetFile (platform_file, module_spec.GetUUIDPtr(), local_file);
|
|
if (error.Success())
|
|
{
|
|
error = ResolveExecutable (local_file, module_spec.GetArchitecture(), module_sp, module_search_paths_ptr);
|
|
}
|
|
else
|
|
{
|
|
const bool always_create = false;
|
|
error = ModuleList::GetSharedModule (module_spec,
|
|
module_sp,
|
|
module_search_paths_ptr,
|
|
old_module_sp_ptr,
|
|
did_create_ptr,
|
|
always_create);
|
|
|
|
}
|
|
if (module_sp)
|
|
module_sp->SetPlatformFileSpec(platform_file);
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
uint32_t
|
|
PlatformiOSSimulator::FindProcesses (const ProcessInstanceInfoMatch &match_info,
|
|
ProcessInstanceInfoList &process_infos)
|
|
{
|
|
// TODO: if connected, send a packet to get the remote process infos by name
|
|
process_infos.Clear();
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
PlatformiOSSimulator::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
|
|
{
|
|
// TODO: if connected, send a packet to get the remote process info
|
|
process_info.Clear();
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
PlatformiOSSimulator::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch)
|
|
{
|
|
if (idx == 0)
|
|
{
|
|
// All iOS simulator binaries are currently i386
|
|
arch = Host::GetArchitecture (Host::eSystemDefaultArchitecture32);
|
|
return arch.IsValid();
|
|
}
|
|
return false;
|
|
}
|