Increase use of svr4 packets to improve performance on POSIX remotes

[fjricci]

Summary

Allows the remote to enumerate the link map when adding and removing
shared libraries, so that lldb doesn't need to read it manually from
the remote's memory.

This provides very large speedups (on the order of 50%) in total
startup time when using the ds2 remote on android or Tizen devices.

[tberghammer]

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

198

This function have a lot of common code with UpdateSUEntries(). It would be good to merge the 2 in some way especially if we consider that they have some platform specific hacks inside what we don't want to diverge between the 2 implementation.

262–268

Please use the isLoadBiasIncorrect function instead

262–274

Please move this into a new function and also use the new function from ReadSOEntryFromMemory. We don't want to duplicate these hacks.

[ADodds]

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

247–365

If your adding AddSOEntriesFromRemote() should the above function be renamed to AddSOEntries() for consistency?

289

As a nitpick there seems to be inconsistent use of { on the same line and on a new line. For lldb it should really be placed on a new line.

396

If your adding RemoveSOEntriesFromRemote() should the above function be renamed to RemoveSOEntries() for consistency?

[ADodds]

include/lldb/Core/LoadedModuleInfoList.h

100

can also be made const.

109

Should we be checking the m_has fields here when making each comparison?

[tfiala]

Aside from the other comments, I'm having a look at it now from the perspective of how it cross-cuts other gdb-remote clients (e.g. OS X/debugserver).

[tfiala]

In D16004#323716, @tfiala wrote:

Aside from the other comments, I'm having a look at it now from the perspective of how it cross-cuts other gdb-remote clients (e.g. OS X/debugserver).

The test suite passes on OS X with this patch applied to r257342.

Assuming the comments from Tamas and Aidan are addressed, it looks good.

[fjricci]

Refactoring and style improvements

[fjricci]

Remove accidental binary file addition

[ADodds]

Looks good to me, assuming that Tamas is happy also.

[tberghammer]

Looks good

[tfiala]

LGTM with latest changes.

[sas]

Committed as r257502.

include/lldb/Core/LoadedModuleInfoList.h

+//===-- LoadedModuleInfoList.h ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_LoadedModuleInfoList_h_
+#define liblldb_LoadedModuleInfoList_h_
+
+// C Includes
+
+// C++ Includes
+#include <vector>
+
+// Other libraries and framework includes
+#include "lldb/lldb-private-forward.h"
+
+namespace lldb_private {
+class LoadedModuleInfoList
+{
+public:
+
+    class LoadedModuleInfo
+    {
+    public:
+
+        enum e_data_point
+        {
+            e_has_name      = 0,
+            e_has_base      ,
+            e_has_dynamic   ,
+            e_has_link_map  ,
+            e_num
+        };
+
+        LoadedModuleInfo ()
+        {
+            for (uint32_t i = 0; i < e_num; ++i)
+                m_has[i] = false;
+        };
+
+        void set_name (const std::string & name)
+        {
+            m_name = name;
+            m_has[e_has_name] = true;
+        }
+        bool get_name (std::string & out) const
+        {
+            out = m_name;
+            return m_has[e_has_name];
+        }
+
+        void set_base (const lldb::addr_t base)
+        {
+            m_base = base;
+            m_has[e_has_base] = true;
+        }
+        bool get_base (lldb::addr_t & out) const
+        {
+            out = m_base;
+            return m_has[e_has_base];
+        }
+
+        void set_base_is_offset (bool is_offset)
+        {
+            m_base_is_offset = is_offset;
+        }
+        bool get_base_is_offset(bool & out) const
+        {
+            out = m_base_is_offset;
+            return m_has[e_has_base];
+        }
+
+        void set_link_map (const lldb::addr_t addr)
+        {
+            m_link_map = addr;
+            m_has[e_has_link_map] = true;
+        }
+        bool get_link_map (lldb::addr_t & out) const
+        {
+            out = m_link_map;
+            return m_has[e_has_link_map];
+        }
+
+        void set_dynamic (const lldb::addr_t addr)
+        {
+            m_dynamic = addr;
+            m_has[e_has_dynamic] = true;
+        }
+        bool get_dynamic (lldb::addr_t & out) const
+        {
+            out = m_dynamic;
+            return m_has[e_has_dynamic];
+        }
+
+        bool has_info (e_data_point datum) const
+        {
+            assert (datum < e_num);
+            return m_has[datum];
+        }
+
+        bool
+        operator == (LoadedModuleInfo const &rhs) const
+        {
+            if (e_num != rhs.e_num)
+                return false;
+
+            for (size_t i = 0; i < e_num; ++i)
+            {
+                if (m_has[i] != rhs.m_has[i])
+                    return false;
+            }
+
+            return (m_base == rhs.m_base) &&
+                   (m_link_map == rhs.m_link_map) &&
+                   (m_dynamic == rhs.m_dynamic) &&
+                   (m_name == rhs.m_name);
+        }
+    protected:
+
+        bool m_has[e_num];
+        std::string m_name;
+        lldb::addr_t m_link_map;
+        lldb::addr_t m_base;
+        bool m_base_is_offset;
+        lldb::addr_t m_dynamic;
+    };
+
+    LoadedModuleInfoList ()
+        : m_list ()
+        , m_link_map (LLDB_INVALID_ADDRESS)
+    {}
+
+    void add (const LoadedModuleInfo & mod)
+    {
+        m_list.push_back (mod);
+    }
+
+    void clear ()
+    {
+        m_list.clear ();
+    }
+
+    std::vector<LoadedModuleInfo> m_list;
+    lldb::addr_t m_link_map;
+};
+} // namespace lldb_private
+
+#endif  // liblldb_LoadedModuleInfoList_h_

include/lldb/Target/Process.h

 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Event.h"
+#include "lldb/Core/LoadedModuleInfoList.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Breakpoint/BreakpointSiteList.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ProcessRunLock.h"
 #include "lldb/Interpreter/Options.h"
#endif // SWIG
     ///    The number of shared libraries that were loaded
     //------------------------------------------------------------------
     virtual size_t
     LoadModules ()
     {
         return 0;
     }
 
+    virtual size_t
+    LoadModules (LoadedModuleInfoList &)
+    {
+       return 0;
+    }
+
 protected:
     virtual JITLoaderList &
     GetJITLoaders ();
 
 public:
     //------------------------------------------------------------------
     /// Get the system runtime plug-in for this process. 
     ///

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h

 #include <list>
 #include <string>
 
 // Other libraries and framework includes
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 #include "lldb/Host/FileSpec.h"
 
+#include "lldb/Core/LoadedModuleInfoList.h"
+
+using lldb_private::LoadedModuleInfoList;
+
 namespace lldb_private {
 class Process;
 }
 
 /// @class DYLDRendezvous
 /// @brief Interface to the runtime linker.
 ///
 /// A structure is present in a processes memory space which is updated by the
protected:
 
     /// Location of the r_debug structure in the inferiors address space.
     lldb::addr_t m_rendezvous_addr;
 
     /// Current and previous snapshots of the rendezvous structure.
     Rendezvous m_current;
     Rendezvous m_previous;
 
+    /// List of currently loaded SO modules
+    LoadedModuleInfoList m_loaded_modules;
+
     /// List of SOEntry objects corresponding to the current link map state.
     SOEntryList m_soentries;
 
     /// List of SOEntry's added to the link map since the last call to Resolve().
     SOEntryList m_added_soentries;
 
     /// List of SOEntry's removed from the link map since the last call to
     /// Resolve().
protected:
 
     /// Reads an SOEntry starting at @p addr.
     bool
     ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry);
 
     /// Updates the current set of SOEntries, the set of added entries, and the
     /// set of removed entries.
     bool
-    UpdateSOEntries();
+    UpdateSOEntries(bool fromRemote = false);
+
+    bool
+    FillSOEntryFromModuleInfo (LoadedModuleInfoList::LoadedModuleInfo const & modInfo,
+                               SOEntry &entry);
+
+    bool
+    SaveSOEntriesFromRemote(LoadedModuleInfoList &module_list);
 
     bool
-    UpdateSOEntriesForAddition();
+    AddSOEntriesFromRemote(LoadedModuleInfoList &module_list);
 
     bool
-    UpdateSOEntriesForDeletion();
+    RemoveSOEntriesFromRemote(LoadedModuleInfoList &module_list);
+
+    bool
+    AddSOEntries();
+
+    bool
+    RemoveSOEntries();
+
+    void
+    UpdateBaseAddrIfNecessary(SOEntry &entry, std::string const &file_path);
 
     bool
     SOEntryIsMainExecutable(const SOEntry &entry);
 
     /// Reads the current list of shared objects according to the link map
     /// supplied by the runtime linker.
     bool
     TakeSnapshot(SOEntryList &entry_list);
 
     enum PThreadField { eSize, eNElem, eOffset };
 
     bool FindMetadata(const char *name, PThreadField field, uint32_t& value);
 };
 
 #endif

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

ResolveRendezvousAddress(Process *process)
     return info_addr;
 }
 
 DYLDRendezvous::DYLDRendezvous(Process *process)
     : m_process(process),
       m_rendezvous_addr(LLDB_INVALID_ADDRESS),
       m_current(),
       m_previous(),
+      m_loaded_modules(),
       m_soentries(),
       m_added_soentries(),
       m_removed_soentries()
 {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 
     m_thread_info.valid = false;
 
DYLDRendezvous::Resolve()
     if (!(cursor = ReadPointer(cursor + padding, &info.ldbase)))
         return false;
 
     // The rendezvous was successfully read.  Update our internal state.
     m_rendezvous_addr = info_addr;
     m_previous = m_current;
     m_current = info;
 
+   if (UpdateSOEntries (true))
+       return true;
+
     return UpdateSOEntries();
 }
 
 bool
 DYLDRendezvous::IsValid()
 {
     return m_rendezvous_addr != LLDB_INVALID_ADDRESS;
 }
 
 bool
-DYLDRendezvous::UpdateSOEntries()
+DYLDRendezvous::UpdateSOEntries(bool fromRemote)
 {
     SOEntry entry;
+    LoadedModuleInfoList module_list;
 
-    if (m_current.map_addr == 0)
+    // If we can't get the SO info from the remote, return failure.
+    if (fromRemote && m_process->LoadModules (module_list) == 0)
+        return false;
+
+    if (!fromRemote && m_current.map_addr == 0)
         return false;
 
     // When the previous and current states are consistent this is the first
     // time we have been asked to update.  Just take a snapshot of the currently
     // loaded modules.
-    if (m_previous.state == eConsistent && m_current.state == eConsistent) 
-        return TakeSnapshot(m_soentries);
+    if (m_previous.state == eConsistent && m_current.state == eConsistent)
+        return fromRemote ? SaveSOEntriesFromRemote(module_list) : TakeSnapshot(m_soentries);
 
     // If we are about to add or remove a shared object clear out the current
     // state and take a snapshot of the currently loaded images.
     if (m_current.state == eAdd || m_current.state == eDelete)
     {
         // Some versions of the android dynamic linker might send two
         // notifications with state == eAdd back to back. Ignore them
         // until we get an eConsistent notification.
         if (!(m_previous.state == eConsistent || (m_previous.state == eAdd && m_current.state == eDelete)))
             return false;
 
         m_soentries.clear();
+        if (fromRemote)
+            return SaveSOEntriesFromRemote(module_list);
+
         m_added_soentries.clear();
         m_removed_soentries.clear();
         return TakeSnapshot(m_soentries);
     }
     assert(m_current.state == eConsistent);
 
     // Otherwise check the previous state to determine what to expect and update
     // accordingly.
     if (m_previous.state == eAdd)
-        return UpdateSOEntriesForAddition();
+        return fromRemote ? AddSOEntriesFromRemote(module_list) : AddSOEntries();
     else if (m_previous.state == eDelete)
-        return UpdateSOEntriesForDeletion();
+        return fromRemote ? RemoveSOEntriesFromRemote(module_list) : RemoveSOEntries();
+
+    return false;
+}
+
+bool
+DYLDRendezvous::FillSOEntryFromModuleInfo (LoadedModuleInfoList::LoadedModuleInfo const & modInfo,
+                                           SOEntry &entry)
+{
+    addr_t link_map_addr;
+    addr_t base_addr;
+    addr_t dyn_addr;
+    std::string name;
+
+    if (!modInfo.get_link_map (link_map_addr) ||
+        !modInfo.get_base (base_addr) ||
+        !modInfo.get_dynamic (dyn_addr) ||
+        !modInfo.get_name (name))
+        return false;
+
+    entry.link_addr = link_map_addr;
+    entry.base_addr = base_addr;
+    entry.dyn_addr = dyn_addr;
+
+    entry.file_spec.SetFile(name, false);
+
+    UpdateBaseAddrIfNecessary(entry, name);
+
+    // not needed if we're using ModuleInfos
+    entry.next = 0;
+    entry.prev = 0;
+    entry.path_addr = 0;
+
+    return true;
+}
+
+bool
+DYLDRendezvous::SaveSOEntriesFromRemote(LoadedModuleInfoList &module_list)
+{
+    for (auto const & modInfo : module_list.m_list)
+    {
+        SOEntry entry;
+        if (!FillSOEntryFromModuleInfo(modInfo, entry))
+            return false;
+
+        // Only add shared libraries and not the executable.
+        if (!SOEntryIsMainExecutable(entry))
+            m_soentries.push_back(entry);
+    }
+
+    m_loaded_modules = module_list;
+    return true;
+
+}
+
+bool
+DYLDRendezvous::AddSOEntriesFromRemote(LoadedModuleInfoList &module_list)
+{
+    for (auto const & modInfo : module_list.m_list)
+    {
+        bool found = false;
+        for (auto const & existing : m_loaded_modules.m_list)
+        {
+            if (modInfo == existing)
+            {
+                found = true;
+                break;
+            }
+        }
+
+        if (found)
+            continue;
+
+        SOEntry entry;
+        if (!FillSOEntryFromModuleInfo(modInfo, entry))
+            return false;
+
+        // Only add shared libraries and not the executable.
+        if (!SOEntryIsMainExecutable(entry))
+            m_soentries.push_back(entry);
+    }
+
+    m_loaded_modules = module_list;
+    return true;
+}
+
+bool
+DYLDRendezvous::RemoveSOEntriesFromRemote(LoadedModuleInfoList &module_list)
+{
+    for (auto const & existing : m_loaded_modules.m_list)
+    {
+        bool found = false;
+        for (auto const & modInfo : module_list.m_list)
+        {
+            if (modInfo == existing)
+            {
+                found = true;
+                break;
+            }
+        }
 
+        if (found)
+            continue;
+
+        SOEntry entry;
+        if (!FillSOEntryFromModuleInfo(existing, entry))
             return false;
+
+        // Only add shared libraries and not the executable.
+        if (!SOEntryIsMainExecutable(entry))
+        {
+            iterator pos = std::find(m_soentries.begin(), m_soentries.end(), entry);
+            if (pos == m_soentries.end())
+                return false;
+
+            m_soentries.erase(pos);
+        }
+    }
+
+    m_loaded_modules = module_list;
+    return true;
 }
- 
 bool
-DYLDRendezvous::UpdateSOEntriesForAddition()
+DYLDRendezvous::AddSOEntries()
 {
     SOEntry entry;
     iterator pos;
 
     assert(m_previous.state == eAdd);
 
     if (m_current.map_addr == 0)
         return false;
for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next)
             m_added_soentries.push_back(entry);
         }
     }
 
     return true;
 }
 
 bool
-DYLDRendezvous::UpdateSOEntriesForDeletion()
+DYLDRendezvous::RemoveSOEntries()
 {
     SOEntryList entry_list;
     iterator pos;
 
     assert(m_previous.state == eDelete);
 
     if (!TakeSnapshot(entry_list))
         return false;

 
 bool
 DYLDRendezvous::SOEntryIsMainExecutable(const SOEntry &entry)
 {
     // On Linux the executable is indicated by an empty path in the entry. On
     // FreeBSD and on Android it is the full path to the executable.
 
     auto triple = m_process->GetTarget().GetArchitecture().GetTriple();
-    switch (triple.getOS()) {
+    switch (triple.getOS())
+    {
         case llvm::Triple::FreeBSD:
             return entry.file_spec == m_exe_file_spec;
         case llvm::Triple::Linux:
             if (triple.isAndroid())
                 return entry.file_spec == m_exe_file_spec;
             return !entry.file_spec;
         default:
             return false;
if (target.GetArchitecture().GetTriple().isAndroid() &&
         (file_path == "/system/bin/linker" || file_path == "/system/bin/linker64"))
     {
         return true;
     }
 
     return false;
 }
 
+void
+DYLDRendezvous::UpdateBaseAddrIfNecessary(SOEntry &entry, std::string const &file_path)
+{
+    // If the load bias reported by the linker is incorrect then fetch the load address of the file
+    // from the proc file system.
+    if (isLoadBiasIncorrect(m_process->GetTarget(), file_path))
+    {
+        lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
+        bool is_loaded = false;
+        Error error = m_process->GetFileLoadAddress(entry.file_spec, is_loaded, load_addr);
+        if (error.Success() && is_loaded)
+            entry.base_addr = load_addr;
+    }
+}
+
 bool
 DYLDRendezvous::ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry)
 {
     entry.clear();
 
     entry.link_addr = addr;
     
     if (!(addr = ReadPointer(addr, &entry.base_addr)))
if (!(addr = ReadPointer(addr, &entry.next)))
         return false;
     
     if (!(addr = ReadPointer(addr, &entry.prev)))
         return false;
 
     std::string file_path = ReadStringFromMemory(entry.path_addr);
     entry.file_spec.SetFile(file_path, false);
 
-    // If the load bias reported by the linker is incorrect then fetch the load address of the file
-    // from the proc file system.
-    if (isLoadBiasIncorrect(m_process->GetTarget(), file_path))
-    {
-        lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
-        bool is_loaded = false;
-        Error error = m_process->GetFileLoadAddress(entry.file_spec, is_loaded, load_addr);
-        if (error.Success() && is_loaded)
-            entry.base_addr = load_addr;
-    }
+    UpdateBaseAddrIfNecessary(entry, file_path);
 
     return true;
 }
 
 
 bool
 DYLDRendezvous::FindMetadata(const char *name, PThreadField field, uint32_t& value)
 {

source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/StringList.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ThreadSafeValue.h"
+#include "lldb/Core/LoadedModuleInfoList.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 
 #include "GDBRemoteCommunicationClient.h"
 #include "GDBRemoteRegisterContext.h"
GetModuleSpec(const FileSpec& module_file_spec,
                   ModuleSpec &module_spec) override;
 
     bool
     GetHostOSVersion(uint32_t &major,
                      uint32_t &minor,
                      uint32_t &update) override;
 
     size_t
+    LoadModules(LoadedModuleInfoList &module_list) override;
+
+    size_t
     LoadModules() override;
 
     Error
     GetFileLoadAddress(const FileSpec& file, bool& is_loaded, lldb::addr_t& load_addr) override;
 
     void
     ModulesDidLoad (ModuleList &module_list) override;
 
     StructuredData::ObjectSP
     GetLoadedDynamicLibrariesInfos (lldb::addr_t image_list_address, lldb::addr_t image_count) override;
 
 protected:
     friend class ThreadGDBRemote;
     friend class GDBRemoteCommunicationClient;
     friend class GDBRemoteRegisterContext;
 
-    class GDBLoadedModuleInfoList;
-
     //------------------------------------------------------------------
     /// Broadcaster event bits definitions.
     //------------------------------------------------------------------
     enum
     {
         eBroadcastBitAsyncContinue                  = (1 << 0),
         eBroadcastBitAsyncThreadShouldExit          = (1 << 1),
         eBroadcastBitAsyncThreadDidExit             = (1 << 2)
protected:
     GetDynamicLoader () override;
 
     // Query remote GDBServer for register information
     bool
     GetGDBServerRegisterInfo ();
 
     // Query remote GDBServer for a detailed loaded library list
     Error
-    GetLoadedModuleList (GDBLoadedModuleInfoList &);
+    GetLoadedModuleList (LoadedModuleInfoList &);
 
     lldb::ModuleSP
     LoadModuleAtAddress (const FileSpec &file, lldb::addr_t base_addr, bool value_is_offset);
 
 private:
     //------------------------------------------------------------------
     // For ProcessGDBRemote only
     //------------------------------------------------------------------

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

GetGlobalPluginProperties()
         static ProcessKDPPropertiesSP g_settings_sp;
         if (!g_settings_sp)
             g_settings_sp.reset (new PluginProperties ());
         return g_settings_sp;
     }
 
 } // anonymous namespace end
 
-class ProcessGDBRemote::GDBLoadedModuleInfoList
-{
-public:
-
-    class LoadedModuleInfo
-    {
-    public:
-
-        enum e_data_point
-        {
-            e_has_name      = 0,
-            e_has_base      ,
-            e_has_dynamic   ,
-            e_has_link_map  ,
-            e_num
-        };
-
-        LoadedModuleInfo ()
-        {
-            for (uint32_t i = 0; i < e_num; ++i)
-                m_has[i] = false;
-        }
-
-        void set_name (const std::string & name)
-        {
-            m_name = name;
-            m_has[e_has_name] = true;
-        }
-        bool get_name (std::string & out) const
-        {
-            out = m_name;
-            return m_has[e_has_name];
-        }
-
-        void set_base (const lldb::addr_t base)
-        {
-            m_base = base;
-            m_has[e_has_base] = true;
-        }
-        bool get_base (lldb::addr_t & out) const
-        {
-            out = m_base;
-            return m_has[e_has_base];
-        }
-
-        void set_base_is_offset (bool is_offset)
-        {
-            m_base_is_offset = is_offset;
-        }
-        bool get_base_is_offset(bool & out) const
-        {
-            out = m_base_is_offset;
-            return m_has[e_has_base];
-        }
-
-        void set_link_map (const lldb::addr_t addr)
-        {
-            m_link_map = addr;
-            m_has[e_has_link_map] = true;
-        }
-        bool get_link_map (lldb::addr_t & out) const
-        {
-            out = m_link_map;
-            return m_has[e_has_link_map];
-        }
-
-        void set_dynamic (const lldb::addr_t addr)
-        {
-            m_dynamic = addr;
-            m_has[e_has_dynamic] = true;
-        }
-        bool get_dynamic (lldb::addr_t & out) const
-        {
-            out = m_dynamic;
-            return m_has[e_has_dynamic];
-        }
-
-        bool has_info (e_data_point datum)
-        {
-            assert (datum < e_num);
-            return m_has[datum];
-        }
-
-    protected:
-
-        bool m_has[e_num];
-        std::string m_name;
-        lldb::addr_t m_link_map;
-        lldb::addr_t m_base;
-        bool m_base_is_offset;
-        lldb::addr_t m_dynamic;
-    };
-
-    GDBLoadedModuleInfoList ()
-        : m_list ()
-        , m_link_map (LLDB_INVALID_ADDRESS)
-    {}
-
-    void add (const LoadedModuleInfo & mod)
-    {
-        m_list.push_back (mod);
-    }
-
-    void clear ()
-    {
-        m_list.clear ();
-    }
-
-    std::vector<LoadedModuleInfo> m_list;
-    lldb::addr_t m_link_map;
-};
-
 // TODO Randomly assigning a port is unsafe.  We should get an unused
 // ephemeral port from the kernel and make sure we reserve it before passing
 // it to debugserver.
 
 #if defined (__APPLE__)
 #define LOW_PORT    (IPPORT_RESERVED)
 #define HIGH_PORT   (IPPORT_HIFIRSTAUTO)
 #else

 ProcessGDBRemote::GetImageInfoAddress()
 {
     // request the link map address via the $qShlibInfoAddr packet
     lldb::addr_t addr = m_gdb_comm.GetShlibInfoAddr();
 
     // the loaded module list can also provides a link map address
     if (addr == LLDB_INVALID_ADDRESS)
     {
-        GDBLoadedModuleInfoList list;
+        LoadedModuleInfoList list;
         if (GetLoadedModuleList (list).Success())
             addr = list.m_link_map;
     }
 
     return addr;
 }
 
 void
if (xml_document.ParseMemory(raw.c_str(), raw.size(), "target.xml"))
             this->m_register_info.Finalize(GetTarget().GetArchitecture());
         }
     }
 
     return m_register_info.GetNumRegisters() > 0;
 }
 
 Error
-ProcessGDBRemote::GetLoadedModuleList (GDBLoadedModuleInfoList & list)
+ProcessGDBRemote::GetLoadedModuleList (LoadedModuleInfoList & list)
 {
     // Make sure LLDB has an XML parser it can use first
     if (!XMLDocument::XMLEnabled())
         return Error (0, ErrorType::eErrorTypeGeneric);
 
     Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS);
     if (log)
         log->Printf ("ProcessGDBRemote::%s", __FUNCTION__);
if (comm.GetQXferLibrariesSVR4ReadSupported ()) {
         llvm::StringRef main_lm = root_element.GetAttributeValue("main-lm");
         if (!main_lm.empty())
         {
             list.m_link_map = StringConvert::ToUInt64(main_lm.data(), LLDB_INVALID_ADDRESS, 0);
         }
 
         root_element.ForEachChildElementWithName("library", [log, &list](const XMLNode &library) -> bool {
 
-            GDBLoadedModuleInfoList::LoadedModuleInfo module;
+            LoadedModuleInfoList::LoadedModuleInfo module;
 
             library.ForEachAttribute([log, &module](const llvm::StringRef &name, const llvm::StringRef &value) -> bool {
 
                 if (name == "name")
                     module.set_name (value.str());
                 else if (name == "lm")
                 {
                     // the address of the link_map struct.
if (comm.GetQXferLibrariesSVR4ReadSupported ()) {
         if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
             return Error (0, ErrorType::eErrorTypeGeneric);
 
         XMLNode root_element = doc.GetRootElement("library-list");
         if (!root_element)
             return Error();
 
         root_element.ForEachChildElementWithName("library", [log, &list](const XMLNode &library) -> bool {
-            GDBLoadedModuleInfoList::LoadedModuleInfo module;
+            LoadedModuleInfoList::LoadedModuleInfo module;
 
             llvm::StringRef name = library.GetAttributeValue("name");
             module.set_name(name.str());
 
             // The base address of a given library will be the address of its
             // first section. Most remotes send only one section for Windows
             // targets for example.
             const XMLNode &section = library.FindFirstChildElementWithName("section");
ProcessGDBRemote::LoadModuleAtAddress (const FileSpec &file, lldb::addr_t base_addr, bool value_is_offset)
     {
         module_sp->SetLoadAddress (target, base_addr, value_is_offset, changed);
     }
 
     return module_sp;
 }
 
 size_t
-ProcessGDBRemote::LoadModules ()
+ProcessGDBRemote::LoadModules (LoadedModuleInfoList &module_list)
 {
     using lldb_private::process_gdb_remote::ProcessGDBRemote;
 
     // request a list of loaded libraries from GDBServer
-    GDBLoadedModuleInfoList module_list;
     if (GetLoadedModuleList (module_list).Fail())
         return 0;
 
     // get a list of all the modules
     ModuleList new_modules;
 
-    for (GDBLoadedModuleInfoList::LoadedModuleInfo & modInfo : module_list.m_list)
+    for (LoadedModuleInfoList::LoadedModuleInfo & modInfo : module_list.m_list)
     {
         std::string  mod_name;
         lldb::addr_t mod_base;
         bool         mod_base_is_offset;
 
         bool valid = true;
         valid &= modInfo.get_name (mod_name);
         valid &= modInfo.get_base (mod_base);
if (new_modules.GetSize() > 0)
         });
 
         ModuleList &loaded_modules = m_process->GetTarget().GetImages();
         loaded_modules.AppendIfNeeded (new_modules);
         m_process->GetTarget().ModulesDidLoad (new_modules);
     }
 
     return new_modules.GetSize();
+
+}
+
+size_t
+ProcessGDBRemote::LoadModules ()
+{
+    LoadedModuleInfoList module_list;
+    return LoadModules (module_list);
 }
 
 Error
 ProcessGDBRemote::GetFileLoadAddress(const FileSpec& file, bool& is_loaded, lldb::addr_t& load_addr)
 {
     is_loaded = false;
     load_addr = LLDB_INVALID_ADDRESS;