1//===-- PlatformRemoteiOS.cpp -----------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "PlatformRemoteiOS.h"
11
12// C Includes
13// C++ Includes
14// Other libraries and framework includes
15// Project includes
16#include "lldb/Breakpoint/BreakpointLocation.h"
17#include "lldb/Core/ArchSpec.h"
18#include "lldb/Core/Error.h"
19#include "lldb/Core/Module.h"
20#include "lldb/Core/ModuleList.h"
21#include "lldb/Core/ModuleSpec.h"
22#include "lldb/Core/PluginManager.h"
23#include "lldb/Core/StreamString.h"
24#include "lldb/Host/FileSpec.h"
25#include "lldb/Host/Host.h"
26#include "lldb/Target/Process.h"
27#include "lldb/Target/Target.h"
28
29using namespace lldb;
30using namespace lldb_private;
31
32PlatformRemoteiOS::SDKDirectoryInfo::SDKDirectoryInfo (const lldb_private::FileSpec &sdk_dir) :
33    directory(sdk_dir),
34    build(),
35    version_major(0),
36    version_minor(0),
37    version_update(0),
38    user_cached(false)
39{
40    const char *dirname_cstr = sdk_dir.GetFilename().GetCString();
41    const char *pos = Args::StringToVersion (dirname_cstr,
42                                             version_major,
43                                             version_minor,
44                                             version_update);
45
46    if (pos && pos[0] == ' ' && pos[1] == '(')
47    {
48        const char *build_start = pos + 2;
49        const char *end_paren = strchr (build_start, ')');
50        if (end_paren && build_start < end_paren)
51            build.SetCStringWithLength(build_start, end_paren - build_start);
52    }
53}
54
55//------------------------------------------------------------------
56// Static Variables
57//------------------------------------------------------------------
58static uint32_t g_initialize_count = 0;
59
60//------------------------------------------------------------------
61// Static Functions
62//------------------------------------------------------------------
63void
64PlatformRemoteiOS::Initialize ()
65{
66    if (g_initialize_count++ == 0)
67    {
68        PluginManager::RegisterPlugin (PlatformRemoteiOS::GetPluginNameStatic(),
69                                       PlatformRemoteiOS::GetDescriptionStatic(),
70                                       PlatformRemoteiOS::CreateInstance);
71    }
72}
73
74void
75PlatformRemoteiOS::Terminate ()
76{
77    if (g_initialize_count > 0)
78    {
79        if (--g_initialize_count == 0)
80        {
81            PluginManager::UnregisterPlugin (PlatformRemoteiOS::CreateInstance);
82        }
83    }
84}
85
86Platform*
87PlatformRemoteiOS::CreateInstance (bool force, const ArchSpec *arch)
88{
89    bool create = force;
90    if (create == false && arch && arch->IsValid())
91    {
92        switch (arch->GetMachine())
93        {
94        case llvm::Triple::arm:
95        case llvm::Triple::thumb:
96            {
97                const llvm::Triple &triple = arch->GetTriple();
98                llvm::Triple::VendorType vendor = triple.getVendor();
99                switch (vendor)
100                {
101                    case llvm::Triple::Apple:
102                        create = true;
103                        break;
104
105#if defined(__APPLE__)
106                    // Only accept "unknown" for the vendor if the host is Apple and
107                    // it "unknown" wasn't specified (it was just returned becasue it
108                    // was NOT specified)
109                    case llvm::Triple::UnknownArch:
110                        create = !arch->TripleVendorWasSpecified();
111                        break;
112
113#endif
114                    default:
115                        break;
116                }
117                if (create)
118                {
119                    switch (triple.getOS())
120                    {
121                        case llvm::Triple::Darwin:  // Deprecated, but still support Darwin for historical reasons
122                        case llvm::Triple::IOS:     // This is the right triple value for iOS debugging
123                            break;
124
125#if defined(__APPLE__)
126                        // Only accept "unknown" for the OS if the host is Apple and
127                        // it "unknown" wasn't specified (it was just returned becasue it
128                        // was NOT specified)
129                        case llvm::Triple::UnknownOS:
130                            create = !arch->TripleOSWasSpecified();
131                            break;
132#endif
133                        default:
134                            create = false;
135                            break;
136                    }
137                }
138            }
139            break;
140        default:
141            break;
142        }
143    }
144
145    if (create)
146        return new PlatformRemoteiOS ();
147    return NULL;
148}
149
150
151lldb_private::ConstString
152PlatformRemoteiOS::GetPluginNameStatic ()
153{
154    static ConstString g_name("remote-ios");
155    return g_name;
156}
157
158const char *
159PlatformRemoteiOS::GetDescriptionStatic()
160{
161    return "Remote iOS platform plug-in.";
162}
163
164
165//------------------------------------------------------------------
166/// Default Constructor
167//------------------------------------------------------------------
168PlatformRemoteiOS::PlatformRemoteiOS () :
169    PlatformDarwin (false),    // This is a remote platform
170    m_sdk_directory_infos(),
171    m_device_support_directory(),
172    m_device_support_directory_for_os_version (),
173    m_build_update(),
174    m_last_module_sdk_idx(UINT32_MAX)
175{
176}
177
178//------------------------------------------------------------------
179/// Destructor.
180///
181/// The destructor is virtual since this class is designed to be
182/// inherited from by the plug-in instance.
183//------------------------------------------------------------------
184PlatformRemoteiOS::~PlatformRemoteiOS()
185{
186}
187
188
189void
190PlatformRemoteiOS::GetStatus (Stream &strm)
191{
192    Platform::GetStatus (strm);
193    const char *sdk_directory = GetDeviceSupportDirectoryForOSVersion();
194    if (sdk_directory)
195        strm.Printf ("  SDK Path: \"%s\"\n", sdk_directory);
196    else
197        strm.PutCString ("  SDK Path: error: unable to locate SDK\n");
198
199    const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
200    for (uint32_t i=0; i<num_sdk_infos; ++i)
201    {
202        const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[i];
203        strm.Printf (" SDK Roots: [%2u] \"%s\"\n",
204                     i,
205                     sdk_dir_info.directory.GetPath().c_str());
206    }
207}
208
209
210Error
211PlatformRemoteiOS::ResolveExecutable (const FileSpec &exe_file,
212                                      const ArchSpec &exe_arch,
213                                      lldb::ModuleSP &exe_module_sp,
214                                      const FileSpecList *module_search_paths_ptr)
215{
216    Error error;
217    // Nothing special to do here, just use the actual file and architecture
218
219    FileSpec resolved_exe_file (exe_file);
220
221    // If we have "ls" as the exe_file, resolve the executable loation based on
222    // the current path variables
223    // TODO: resolve bare executables in the Platform SDK
224//    if (!resolved_exe_file.Exists())
225//        resolved_exe_file.ResolveExecutableLocation ();
226
227    // Resolve any executable within a bundle on MacOSX
228    // TODO: verify that this handles shallow bundles, if not then implement one ourselves
229    Host::ResolveExecutableInBundle (resolved_exe_file);
230
231    if (resolved_exe_file.Exists())
232    {
233        if (exe_arch.IsValid())
234        {
235            ModuleSpec module_spec (resolved_exe_file, exe_arch);
236            error = ModuleList::GetSharedModule (module_spec,
237                                                 exe_module_sp,
238                                                 NULL,
239                                                 NULL,
240                                                 NULL);
241
242            if (exe_module_sp && exe_module_sp->GetObjectFile())
243                return error;
244            exe_module_sp.reset();
245        }
246        // No valid architecture was specified or the exact ARM slice wasn't
247        // found so ask the platform for the architectures that we should be
248        // using (in the correct order) and see if we can find a match that way
249        StreamString arch_names;
250        ArchSpec platform_arch;
251        for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, platform_arch); ++idx)
252        {
253            ModuleSpec module_spec (resolved_exe_file, platform_arch);
254            error = ModuleList::GetSharedModule (module_spec,
255                                                 exe_module_sp,
256                                                 NULL,
257                                                 NULL,
258                                                 NULL);
259            // Did we find an executable using one of the
260            if (error.Success())
261            {
262                if (exe_module_sp && exe_module_sp->GetObjectFile())
263                    break;
264                else
265                    error.SetErrorToGenericError();
266            }
267
268            if (idx > 0)
269                arch_names.PutCString (", ");
270            arch_names.PutCString (platform_arch.GetArchitectureName());
271        }
272
273        if (error.Fail() || !exe_module_sp)
274        {
275            error.SetErrorStringWithFormat ("'%s' doesn't contain any '%s' platform architectures: %s",
276                                            exe_file.GetPath().c_str(),
277                                            GetPluginName().GetCString(),
278                                            arch_names.GetString().c_str());
279        }
280    }
281    else
282    {
283        error.SetErrorStringWithFormat ("'%s' does not exist",
284                                        exe_file.GetPath().c_str());
285    }
286
287    return error;
288}
289
290FileSpec::EnumerateDirectoryResult
291PlatformRemoteiOS::GetContainedFilesIntoVectorOfStringsCallback (void *baton,
292                                                                 FileSpec::FileType file_type,
293                                                                 const FileSpec &file_spec)
294{
295    ((PlatformRemoteiOS::SDKDirectoryInfoCollection *)baton)->push_back(PlatformRemoteiOS::SDKDirectoryInfo(file_spec));
296    return FileSpec::eEnumerateDirectoryResultNext;
297}
298
299bool
300PlatformRemoteiOS::UpdateSDKDirectoryInfosInNeeded()
301{
302    if (m_sdk_directory_infos.empty())
303    {
304        const char *device_support_dir = GetDeviceSupportDirectory();
305        if (device_support_dir)
306        {
307            const bool find_directories = true;
308            const bool find_files = false;
309            const bool find_other = false;
310            FileSpec::EnumerateDirectory (m_device_support_directory.c_str(),
311                                          find_directories,
312                                          find_files,
313                                          find_other,
314                                          GetContainedFilesIntoVectorOfStringsCallback,
315                                          &m_sdk_directory_infos);
316
317            const uint32_t num_installed = m_sdk_directory_infos.size();
318            FileSpec local_sdk_cache("~/Library/Developer/Xcode/iOS DeviceSupport", true);
319            if (local_sdk_cache.Exists())
320            {
321                char path[PATH_MAX];
322                if (local_sdk_cache.GetPath(path, sizeof(path)))
323                {
324                    FileSpec::EnumerateDirectory (path,
325                                                  find_directories,
326                                                  find_files,
327                                                  find_other,
328                                                  GetContainedFilesIntoVectorOfStringsCallback,
329                                                  &m_sdk_directory_infos);
330                    const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
331                    // First try for an exact match of major, minor and update
332                    for (uint32_t i=num_installed; i<num_sdk_infos; ++i)
333                    {
334                        m_sdk_directory_infos[i].user_cached = true;
335                    }
336                }
337            }
338        }
339    }
340    return !m_sdk_directory_infos.empty();
341}
342
343const PlatformRemoteiOS::SDKDirectoryInfo *
344PlatformRemoteiOS::GetSDKDirectoryForCurrentOSVersion ()
345{
346    uint32_t i;
347    if (UpdateSDKDirectoryInfosInNeeded())
348    {
349        const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
350
351        // Check to see if the user specified a build string. If they did, then
352        // be sure to match it.
353        std::vector<bool> check_sdk_info(num_sdk_infos, true);
354        ConstString build(m_sdk_build);
355        if (build)
356        {
357            for (i=0; i<num_sdk_infos; ++i)
358                check_sdk_info[i] = m_sdk_directory_infos[i].build == build;
359        }
360
361        // If we are connected we can find the version of the OS the platform
362        // us running on and select the right SDK
363        uint32_t major, minor, update;
364        if (GetOSVersion(major, minor, update))
365        {
366            if (UpdateSDKDirectoryInfosInNeeded())
367            {
368                // First try for an exact match of major, minor and update
369                for (i=0; i<num_sdk_infos; ++i)
370                {
371                    if (check_sdk_info[i])
372                    {
373                        if (m_sdk_directory_infos[i].version_major == major &&
374                            m_sdk_directory_infos[i].version_minor == minor &&
375                            m_sdk_directory_infos[i].version_update == update)
376                        {
377                            return &m_sdk_directory_infos[i];
378                        }
379                    }
380                }
381                // First try for an exact match of major and minor
382                for (i=0; i<num_sdk_infos; ++i)
383                {
384                    if (check_sdk_info[i])
385                    {
386                        if (m_sdk_directory_infos[i].version_major == major &&
387                            m_sdk_directory_infos[i].version_minor == minor)
388                        {
389                            return &m_sdk_directory_infos[i];
390                        }
391                    }
392                }
393                // Lastly try to match of major version only..
394                for (i=0; i<num_sdk_infos; ++i)
395                {
396                    if (check_sdk_info[i])
397                    {
398                        if (m_sdk_directory_infos[i].version_major == major)
399                        {
400                            return &m_sdk_directory_infos[i];
401                        }
402                    }
403                }
404            }
405        }
406        else if (build)
407        {
408            // No version, just a build number, search for the first one that matches
409            for (i=0; i<num_sdk_infos; ++i)
410                if (check_sdk_info[i])
411                    return &m_sdk_directory_infos[i];
412        }
413    }
414    return NULL;
415}
416
417const PlatformRemoteiOS::SDKDirectoryInfo *
418PlatformRemoteiOS::GetSDKDirectoryForLatestOSVersion ()
419{
420    const PlatformRemoteiOS::SDKDirectoryInfo *result = NULL;
421    if (UpdateSDKDirectoryInfosInNeeded())
422    {
423        const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
424        // First try for an exact match of major, minor and update
425        for (uint32_t i=0; i<num_sdk_infos; ++i)
426        {
427            const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[i];
428            if (sdk_dir_info.version_major != UINT32_MAX)
429            {
430                if (result == NULL || sdk_dir_info.version_major > result->version_major)
431                {
432                    result = &sdk_dir_info;
433                }
434                else if (sdk_dir_info.version_major == result->version_major)
435                {
436                    if (sdk_dir_info.version_minor > result->version_minor)
437                    {
438                        result = &sdk_dir_info;
439                    }
440                    else if (sdk_dir_info.version_minor == result->version_minor)
441                    {
442                        if (sdk_dir_info.version_update > result->version_update)
443                        {
444                            result = &sdk_dir_info;
445                        }
446                    }
447                }
448            }
449        }
450    }
451    return result;
452}
453
454
455
456const char *
457PlatformRemoteiOS::GetDeviceSupportDirectory()
458{
459    if (m_device_support_directory.empty())
460    {
461        const char *device_support_dir = GetDeveloperDirectory();
462        if (device_support_dir)
463        {
464            m_device_support_directory.assign (device_support_dir);
465            m_device_support_directory.append ("/Platforms/iPhoneOS.platform/DeviceSupport");
466        }
467        else
468        {
469            // Assign a single NULL character so we know we tried to find the device
470            // support directory and we don't keep trying to find it over and over.
471            m_device_support_directory.assign (1, '\0');
472        }
473    }
474    // We should have put a single NULL character into m_device_support_directory
475    // or it should have a valid path if the code gets here
476    assert (m_device_support_directory.empty() == false);
477    if (m_device_support_directory[0])
478        return m_device_support_directory.c_str();
479    return NULL;
480}
481
482
483const char *
484PlatformRemoteiOS::GetDeviceSupportDirectoryForOSVersion()
485{
486    if (m_sdk_sysroot)
487        return m_sdk_sysroot.GetCString();
488
489    if (m_device_support_directory_for_os_version.empty())
490    {
491        const PlatformRemoteiOS::SDKDirectoryInfo *sdk_dir_info = GetSDKDirectoryForCurrentOSVersion ();
492        if (sdk_dir_info == NULL)
493            sdk_dir_info = GetSDKDirectoryForLatestOSVersion ();
494        if (sdk_dir_info)
495        {
496            char path[PATH_MAX];
497            if (sdk_dir_info->directory.GetPath(path, sizeof(path)))
498            {
499                m_device_support_directory_for_os_version = path;
500                return m_device_support_directory_for_os_version.c_str();
501            }
502        }
503        else
504        {
505            // Assign a single NULL character so we know we tried to find the device
506            // support directory and we don't keep trying to find it over and over.
507            m_device_support_directory_for_os_version.assign (1, '\0');
508        }
509    }
510    // We should have put a single NULL character into m_device_support_directory_for_os_version
511    // or it should have a valid path if the code gets here
512    assert (m_device_support_directory_for_os_version.empty() == false);
513    if (m_device_support_directory_for_os_version[0])
514        return m_device_support_directory_for_os_version.c_str();
515    return NULL;
516}
517
518uint32_t
519PlatformRemoteiOS::FindFileInAllSDKs (const char *platform_file_path,
520                                      FileSpecList &file_list)
521{
522    if (platform_file_path && platform_file_path[0] && UpdateSDKDirectoryInfosInNeeded())
523    {
524        const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
525        lldb_private::FileSpec local_file;
526        // First try for an exact match of major, minor and update
527        for (uint32_t sdk_idx=0; sdk_idx<num_sdk_infos; ++sdk_idx)
528        {
529            if (GetFileInSDK (platform_file_path,
530                              sdk_idx,
531                              local_file))
532            {
533                file_list.Append(local_file);
534            }
535        }
536    }
537    return file_list.GetSize();
538}
539
540bool
541PlatformRemoteiOS::GetFileInSDK (const char *platform_file_path,
542                                 uint32_t sdk_idx,
543                                 lldb_private::FileSpec &local_file)
544{
545    if (sdk_idx < m_sdk_directory_infos.size())
546    {
547        char sdkroot_path[PATH_MAX];
548        const SDKDirectoryInfo &sdk_dir_info = m_sdk_directory_infos[sdk_idx];
549        if (sdk_dir_info.directory.GetPath(sdkroot_path, sizeof(sdkroot_path)))
550        {
551            const bool symbols_dirs_only = true;
552
553            return GetFileInSDKRoot (platform_file_path,
554                                     sdkroot_path,
555                                     symbols_dirs_only,
556                                     local_file);
557        }
558    }
559    return false;
560}
561
562
563bool
564PlatformRemoteiOS::GetFileInSDKRoot (const char *platform_file_path,
565                                     const char *sdkroot_path,
566                                     bool symbols_dirs_only,
567                                     lldb_private::FileSpec &local_file)
568{
569    if (sdkroot_path && sdkroot_path[0] && platform_file_path && platform_file_path[0])
570    {
571        char resolved_path[PATH_MAX];
572
573        if (!symbols_dirs_only)
574        {
575            ::snprintf (resolved_path,
576                        sizeof(resolved_path),
577                        "%s/%s",
578                        sdkroot_path,
579                        platform_file_path);
580
581            local_file.SetFile(resolved_path, true);
582            if (local_file.Exists())
583                return true;
584        }
585
586        ::snprintf (resolved_path,
587                    sizeof(resolved_path),
588                    "%s/Symbols.Internal/%s",
589                    sdkroot_path,
590                    platform_file_path);
591
592        local_file.SetFile(resolved_path, true);
593        if (local_file.Exists())
594            return true;
595        ::snprintf (resolved_path,
596                    sizeof(resolved_path),
597                    "%s/Symbols/%s",
598                    sdkroot_path,
599                    platform_file_path);
600
601        local_file.SetFile(resolved_path, true);
602        if (local_file.Exists())
603            return true;
604    }
605    return false;
606}
607
608
609Error
610PlatformRemoteiOS::GetSymbolFile (const FileSpec &platform_file,
611                                  const UUID *uuid_ptr,
612                                  FileSpec &local_file)
613{
614    Error error;
615    char platform_file_path[PATH_MAX];
616    if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path)))
617    {
618        char resolved_path[PATH_MAX];
619
620        const char * os_version_dir = GetDeviceSupportDirectoryForOSVersion();
621        if (os_version_dir)
622        {
623            ::snprintf (resolved_path,
624                        sizeof(resolved_path),
625                        "%s/%s",
626                        os_version_dir,
627                        platform_file_path);
628
629            local_file.SetFile(resolved_path, true);
630            if (local_file.Exists())
631                return error;
632
633            ::snprintf (resolved_path,
634                        sizeof(resolved_path),
635                        "%s/Symbols.Internal/%s",
636                        os_version_dir,
637                        platform_file_path);
638
639            local_file.SetFile(resolved_path, true);
640            if (local_file.Exists())
641                return error;
642            ::snprintf (resolved_path,
643                        sizeof(resolved_path),
644                        "%s/Symbols/%s",
645                        os_version_dir,
646                        platform_file_path);
647
648            local_file.SetFile(resolved_path, true);
649            if (local_file.Exists())
650                return error;
651
652        }
653        local_file = platform_file;
654        if (local_file.Exists())
655            return error;
656
657        error.SetErrorStringWithFormat ("unable to locate a platform file for '%s' in platform '%s'",
658                                        platform_file_path,
659                                        GetPluginName().GetCString());
660    }
661    else
662    {
663        error.SetErrorString ("invalid platform file argument");
664    }
665    return error;
666}
667
668Error
669PlatformRemoteiOS::GetSharedModule (const ModuleSpec &module_spec,
670                                    ModuleSP &module_sp,
671                                    const FileSpecList *module_search_paths_ptr,
672                                    ModuleSP *old_module_sp_ptr,
673                                    bool *did_create_ptr)
674{
675    // For iOS, the SDK files are all cached locally on the host
676    // system. So first we ask for the file in the cached SDK,
677    // then we attempt to get a shared module for the right architecture
678    // with the right UUID.
679    const FileSpec &platform_file = module_spec.GetFileSpec();
680
681    FileSpec local_file;
682    const UUID *module_uuid_ptr = module_spec.GetUUIDPtr();
683    Error error (GetSymbolFile (platform_file, module_uuid_ptr, local_file));
684    if (error.Success())
685    {
686        error = ResolveExecutable (local_file, module_spec.GetArchitecture(), module_sp, NULL);
687        if (module_sp && ((module_uuid_ptr == NULL) || (module_sp->GetUUID() == *module_uuid_ptr)))
688        {
689            //printf ("found in user specified SDK\n");
690            error.Clear();
691            return error;
692        }
693
694        char platform_file_path[PATH_MAX];
695        if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path)))
696        {
697            FileSpec local_file;
698            const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
699            // Try the last SDK index if it is set as most files from an SDK
700            // will tend to be valid in that same SDK.
701            if (m_last_module_sdk_idx < num_sdk_infos)
702            {
703                if (GetFileInSDK (platform_file_path, m_last_module_sdk_idx, local_file))
704                {
705                    //printf ("sdk[%u] last: '%s'\n", m_last_module_sdk_idx, local_file.GetPath().c_str());
706                    module_sp.reset();
707                    error = ResolveExecutable (local_file,
708                                               module_spec.GetArchitecture(),
709                                               module_sp,
710                                               NULL);
711                    if (module_sp && ((module_uuid_ptr == NULL) || (module_sp->GetUUID() == *module_uuid_ptr)))
712                    {
713                        //printf ("sdk[%u] last found\n", m_last_module_sdk_idx);
714                        error.Clear();
715                        return error;
716                    }
717                }
718            }
719
720            // First try for an exact match of major, minor and update
721            for (uint32_t sdk_idx=0; sdk_idx<num_sdk_infos; ++sdk_idx)
722            {
723                if (m_last_module_sdk_idx == sdk_idx)
724                {
725                    // Skip the last module SDK index if we already searched
726                    // it above
727                    continue;
728                }
729                if (GetFileInSDK (platform_file_path, sdk_idx, local_file))
730                {
731                    //printf ("sdk[%u]: '%s'\n", sdk_idx, local_file.GetPath().c_str());
732
733                    error = ResolveExecutable (local_file,
734                                               module_spec.GetArchitecture(),
735                                               module_sp,
736                                               NULL);
737                    if (module_sp && ((module_uuid_ptr == NULL) || (module_sp->GetUUID() == *module_uuid_ptr)))
738                    {
739                        // Remember the index of the last SDK that we found a file
740                        // in in case the wrong SDK was selected.
741                        m_last_module_sdk_idx = sdk_idx;
742                        //printf ("sdk[%u]: found (setting last to %u)\n", sdk_idx, m_last_module_sdk_idx);
743                        error.Clear();
744                        return error;
745                    }
746                }
747            }
748        }
749        // Not the module we are looking for... Nothing to see here...
750        module_sp.reset();
751    }
752
753    const bool always_create = false;
754    error = ModuleList::GetSharedModule (module_spec,
755                                         module_sp,
756                                         module_search_paths_ptr,
757                                         old_module_sp_ptr,
758                                         did_create_ptr,
759                                         always_create);
760
761    if (module_sp)
762        module_sp->SetPlatformFileSpec(platform_file);
763
764    return error;
765}
766
767
768uint32_t
769PlatformRemoteiOS::FindProcesses (const ProcessInstanceInfoMatch &match_info,
770                                  ProcessInstanceInfoList &process_infos)
771{
772    // TODO: if connected, send a packet to get the remote process infos by name
773    process_infos.Clear();
774    return 0;
775}
776
777bool
778PlatformRemoteiOS::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
779{
780    // TODO: if connected, send a packet to get the remote process info
781    process_info.Clear();
782    return false;
783}
784
785bool
786PlatformRemoteiOS::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch)
787{
788    return ARMGetSupportedArchitectureAtIndex (idx, arch);
789}
790