Fetch module specification from remote process also

[tberghammer]

Summary

Fetch module specification from remote process also

Previously the remote module specification was fetched only from the
remote platform. With this CL if we have a remote process then we ask it
if it have any information from a given module. It is required because
on android the dynamic linker only reports the name of the SO file and
the platform can't always find it without a full path (the process can
do it based on /proc/<pid>/maps).

[clayborg]

Fix the "std::string" arguments as noted in inline comments and this is good to go.

include/lldb/Host/common/NativeProcessProtocol.h

291 ↗

(On Diff #22467)

change this parameter to "const char *' or a "const llvm::StringRef &" unless there really is a need for a std::string.

include/lldb/Target/Process.h

3009 ↗

(On Diff #22467)

add a "module_spec.Clear();" before the return false.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3983 ↗

(On Diff #22467)

change argument to "const char *" or "const llvm::StringRef &"

[tberghammer]

Address issues requested in review

BTW: Why do we prefer const char* and const StringRef& over const std::string&? (My problem with const StringRef& is that it isn't necessarily null terminated so it is expensive to convert it to a c-string while with a const char* we possibly have to check for nullptr and it is expensive to get the length of the string.)

[ovyalov]

Looks good - please see my comment.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3982 ↗

(On Diff #22499)

What do you think about returning Error if sth bad happens? No maps file, failed to open it...

[clayborg]

Its mainly an efficiency thing. If you have a std::string you might need to allocate data on the heap to store the string just to make the call. Since this argument is a path, it is more likely to have to allocate on the heap. Most std::string implementations store the first 20 some bytes in the std::string itself, but if it goes over, it will need to malloc a buffer for the string and make a copy. Most path arguments in the standard libraries and in functions already take "const char *" for paths, so it is just keeping the argument in the currency that most people want is good. I also don't like llvm::StringRef for the path because if you want to guarantee NULL terminate you will need to call my_str.str().c_str() which makes a temp std::string using the length, so I do think "const char *" is the best for the API.

[tberghammer]

Return error from GetLoadedModuleFileSpec

lldb/trunk/include/lldb/Host/common/NativeProcessProtocol.h

public:
         //------------------------------------------------------------------
         bool
         UnregisterNativeDelegate (NativeDelegate &native_delegate);
 
         // Called before termination of NativeProcessProtocol's instance.
         virtual void
         Terminate ();
 
+        virtual Error
+        GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec) = 0;
+
     protected:
         lldb::pid_t m_pid;
 
         std::vector<NativeThreadProtocolSP> m_threads;
         lldb::tid_t m_current_thread_id;
         mutable Mutex m_threads_mutex;
 
         lldb::StateType m_state;

lldb/trunk/include/lldb/Target/Platform.h

//        FindPlugin (Process *process, const ConstString &plugin_name);
         //
         // Locating the file should happen only on the local computer or using
         // the current computers global settings.
         //----------------------------------------------------------------------
         virtual FileSpecList
         LocateExecutableScriptingResources (Target *target,
                                             Module &module,
                                             Stream* feedback_stream);
-        
         virtual Error
-        GetSharedModule (const ModuleSpec &module_spec, 
+        GetSharedModule (const ModuleSpec &module_spec,
+                         Process* process,
                          lldb::ModuleSP &module_sp,
                          const FileSpecList *module_search_paths_ptr,
                          lldb::ModuleSP *old_module_sp_ptr,
                          bool *did_create_ptr);
 
         virtual bool
         GetModuleSpec (const FileSpec& module_file_spec,
                        const ArchSpec& arch,
protected:
         Error
         GetCachedExecutable (ModuleSpec &module_spec,
                              lldb::ModuleSP &module_sp,
                              const FileSpecList *module_search_paths_ptr,
                              Platform &remote_platform);
 
         bool
         GetCachedSharedModule (const ModuleSpec &module_spec,
+                               Process* process,
                                lldb::ModuleSP &module_sp);
 
         Error
         DownloadModuleSlice (const FileSpec& src_file_spec,
                              const uint64_t src_offset,
                              const uint64_t src_size,
                              const FileSpec& dst_file_spec);
 
         bool
         GetModuleFromLocalCache (const ModuleSpec& module_spec,
+                                 Process* process,
                                  lldb::ModuleSP &module_sp);
 
         FileSpec GetModuleCacheRoot ();
 
     private:
         Error
         LoadCachedExecutable (const ModuleSpec &module_spec,
                               lldb::ModuleSP &module_sp,

lldb/trunk/include/lldb/Target/Process.h

public:
     RunPreResumeActions ();
     
     void
     ClearPreResumeActions ();
             
     ProcessRunLock &
     GetRunLock ();
 
-public:
     virtual Error
     SendEventData(const char *data)
     {
         Error return_error ("Sending an event is not supported for this process.");
         return return_error;
     }
     
     lldb::ThreadCollectionSP
     GetHistoryThreads(lldb::addr_t addr);
 
     lldb::InstrumentationRuntimeSP
     GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type);
 
+    //------------------------------------------------------------------
+    /// Try to fetch the module specification for a module with the
+    /// given file name and architecture. Process sub-classes have to
+    /// override this method if they support platforms where the
+    /// Platform object can't get the module spec for all module.
+    ///
+    /// @param[in] module_file_spec
+    ///     The file name of the module to get specification for.
+    ///
+    /// @param[in] arch
+    ///     The architecture of the module to get specification for.
+    ///
+    /// @param[out] module_spec
+    ///     The fetched module specification if the return value is
+    ///     \b true, unchanged otherwise.
+    ///
+    /// @return
+    ///     Returns \b true if the module spec fetched successfully,
+    ///     \b false otherwise.
+    //------------------------------------------------------------------
+    virtual bool
+    GetModuleSpec(const FileSpec& module_file_spec, const ArchSpec& arch, ModuleSpec &module_spec);
+
 protected:
 
     //------------------------------------------------------------------
     // NextEventAction provides a way to register an action on the next
     // event that is delivered to this process.  There is currently only
     // one next event action allowed in the process at one time.  If a
     // new "NextEventAction" is added while one is already present, the
     // old action will be discarded (with HandleBeingUnshipped called 

lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h

public:
 
     // Only on PlatformMacOSX:
     virtual lldb_private::Error
     GetFileWithUUID (const lldb_private::FileSpec &platform_file,
                      const lldb_private::UUID* uuid, lldb_private::FileSpec &local_file);
 
     lldb_private::Error
     GetSharedModule (const lldb_private::ModuleSpec &module_spec,
+                     lldb_private::Process* process,
                      lldb::ModuleSP &module_sp,
                      const lldb_private::FileSpecList *module_search_paths_ptr,
                      lldb::ModuleSP *old_module_sp_ptr,
-                     bool *did_create_ptr);
+                     bool *did_create_ptr) override;
 
     virtual bool
     GetSupportedArchitectureAtIndex (uint32_t idx, lldb_private::ArchSpec &arch);
 
     virtual void
     GetStatus (lldb_private::Stream &strm);
 
     virtual void

lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

PlatformFreeBSD::GetFileWithUUID (const FileSpec &platform_file,
 
     // Default to the local case
     local_file = platform_file;
     return Error();
 }
 
 Error
 PlatformFreeBSD::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)
 {
     Error error;
     module_sp.reset();
 
     if (IsRemote())
     {
         // If we have a remote platform always, let it try and locate
         // the shared module first.
         if (m_remote_platform_sp)
         {
             error = m_remote_platform_sp->GetSharedModule (module_spec,
+                                                           process,
                                                            module_sp,
                                                            module_search_paths_ptr,
                                                            old_module_sp_ptr,
                                                            did_create_ptr);
         }
     }
 
     if (!module_sp)
     {
         // Fall back to the local platform and find the file locally
         error = Platform::GetSharedModule (module_spec,
+                                           process,
                                            module_sp,
                                            module_search_paths_ptr,
                                            old_module_sp_ptr,
                                            did_create_ptr);
     }
     if (module_sp)
         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
     return error;

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.h

public:
     ResolveSymbolFile (lldb_private::Target &target,
                        const lldb_private::ModuleSpec &sym_spec,
                        lldb_private::FileSpec &sym_file) override;
 
     lldb_private::FileSpecList
     LocateExecutableScriptingResources (lldb_private::Target *target,
                                         lldb_private::Module &module,
                                         lldb_private::Stream* feedback_stream) override;
-    
     lldb_private::Error
     GetSharedModule (const lldb_private::ModuleSpec &module_spec,
+                     lldb_private::Process* process,
                      lldb::ModuleSP &module_sp,
                      const lldb_private::FileSpecList *module_search_paths_ptr,
                      lldb::ModuleSP *old_module_sp_ptr,
                      bool *did_create_ptr) override;
 
     size_t
     GetSoftwareBreakpointTrapOpcode (lldb_private::Target &target, 
                                      lldb_private::BreakpointSite *bp_site) override;

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

PlatformDarwin::ResolveExecutable (const ModuleSpec &module_spec,
     }
     
 
     if (error.Success())
     {
         if (resolved_module_spec.GetArchitecture().IsValid())
         {
             error = ModuleList::GetSharedModule (resolved_module_spec,
-                                                 exe_module_sp, 
+                                                 exe_module_sp,
                                                  module_search_paths_ptr,
-                                                 NULL, 
+                                                 NULL,
                                                  NULL);
-        
             if (error.Fail() || exe_module_sp.get() == NULL || exe_module_sp->GetObjectFile() == NULL)
             {
                 exe_module_sp.reset();
                 error.SetErrorStringWithFormat ("'%s' doesn't contain the architecture %s",
                                                 resolved_module_spec.GetFileSpec().GetPath().c_str(),
                                                 resolved_module_spec.GetArchitecture().GetArchitectureName());
             }
         }
         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
             StreamString arch_names;
             for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, resolved_module_spec.GetArchitecture()); ++idx)
             {
                 error = GetSharedModule (resolved_module_spec,
-                                         exe_module_sp, 
+                                         NULL,
+                                         exe_module_sp,
                                          module_search_paths_ptr,
-                                         NULL, 
+                                         NULL,
                                          NULL);
-                // Did we find an executable using one of the 
+                // 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 (!IsHost())
             return Error("no cache path");
     }
     else
         return Error ("unable to resolve module");
 }
 
 Error
 PlatformDarwin::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)
 {
     Error error;
     module_sp.reset();
     
     if (IsRemote())
     {
         // If we have a remote platform always, let it try and locate
         // the shared module first.
         if (m_remote_platform_sp)
         {
             error = m_remote_platform_sp->GetSharedModule (module_spec,
+                                                           process,
                                                            module_sp,
                                                            module_search_paths_ptr,
                                                            old_module_sp_ptr,
                                                            did_create_ptr);
         }
     }
     
     if (!module_sp)
     {
         // Fall back to the local platform and find the file locally
         error = Platform::GetSharedModule (module_spec,
+                                           process,
                                            module_sp,
                                            module_search_paths_ptr,
                                            old_module_sp_ptr,
                                            did_create_ptr);
         
         const FileSpec &platform_file = module_spec.GetFileSpec();
         if (!module_sp && module_search_paths_ptr && platform_file)
         {
             // We can try to pull off part of the file path up to the bundle
             // directory level and try any module search paths...
             FileSpec bundle_directory;
             if (Host::GetBundleDirectory (platform_file, bundle_directory))
             {
                 if (platform_file == bundle_directory)
                 {
                     ModuleSpec new_module_spec (module_spec);
                     new_module_spec.GetFileSpec() = bundle_directory;
                     if (Host::ResolveExecutableInBundle (new_module_spec.GetFileSpec()))
                     {
                         Error new_error (Platform::GetSharedModule (new_module_spec,
+                                                                    process,
                                                                     module_sp,
                                                                     NULL,
                                                                     old_module_sp_ptr,
                                                                     did_create_ptr));
                         
                         if (module_sp)
                             return new_error;
                     }
if (!module_sp)
                         {
                             snprintf (new_path + search_path_len, sizeof(new_path) - search_path_len, "/%s", platform_path + bundle_directory_len);
                             FileSpec new_file_spec (new_path, false);
                             if (new_file_spec.Exists())
                             {
                                 ModuleSpec new_module_spec (module_spec);
                                 new_module_spec.GetFileSpec() = new_file_spec;
                                 Error new_error (Platform::GetSharedModule (new_module_spec,
+                                                                            process,
                                                                             module_sp,
                                                                             NULL,
                                                                             old_module_sp_ptr,
                                                                             did_create_ptr));
                                 
                                 if (module_sp)
                                 {
                                     module_sp->SetPlatformFileSpec(new_file_spec);

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformMacOSX.h

public:
     uint32_t
     GetPluginVersion() override
     {
         return 1;
     }
     
     lldb_private::Error
     GetSharedModule (const lldb_private::ModuleSpec &module_spec,
+                     lldb_private::Process* process,
                      lldb::ModuleSP &module_sp,
                      const lldb_private::FileSpecList *module_search_paths_ptr,
                      lldb::ModuleSP *old_module_sp_ptr,
                      bool *did_create_ptr) override;
     
     const char *
     GetDescription () override
     {

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
     return ARMGetSupportedArchitectureAtIndex (idx, arch);
 #else
     return x86GetSupportedArchitectureAtIndex (idx, arch);
 #endif
 }
 
 lldb_private::Error
 PlatformMacOSX::GetSharedModule (const lldb_private::ModuleSpec &module_spec,
+                                 Process* process,
                                  lldb::ModuleSP &module_sp,
                                  const lldb_private::FileSpecList *module_search_paths_ptr,
                                  lldb::ModuleSP *old_module_sp_ptr,
                                  bool *did_create_ptr)
 {
     Error error = GetSharedModuleWithLocalCache(module_spec, module_sp, module_search_paths_ptr, old_module_sp_ptr, did_create_ptr);
     
     if (module_sp)

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.h

public:
 
     virtual lldb_private::Error
     GetSymbolFile (const lldb_private::FileSpec &platform_file, 
                    const lldb_private::UUID *uuid_ptr,
                    lldb_private::FileSpec &local_file);
 
     lldb_private::Error
     GetSharedModule (const lldb_private::ModuleSpec &module_spec,
+                     lldb_private::Process* process,
                      lldb::ModuleSP &module_sp,
                      const lldb_private::FileSpecList *module_search_paths_ptr,
                      lldb::ModuleSP *old_module_sp_ptr,
                      bool *did_create_ptr) override;
 
     bool
     GetSupportedArchitectureAtIndex (uint32_t idx, 
                                      lldb_private::ArchSpec &arch) override;

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

PlatformRemoteiOS::GetSymbolFile (const FileSpec &platform_file,
     {
         error.SetErrorString ("invalid platform file argument");
     }
     return error;
 }
 
 Error
 PlatformRemoteiOS::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)
 {
     // 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

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.h

public:
 
     virtual lldb_private::Error
     GetSymbolFile (const lldb_private::FileSpec &platform_file, 
                    const lldb_private::UUID *uuid_ptr,
                    lldb_private::FileSpec &local_file);
 
     lldb_private::Error
     GetSharedModule (const lldb_private::ModuleSpec &module_spec,
+                     lldb_private::Process* process,
                      lldb::ModuleSP &module_sp,
                      const lldb_private::FileSpecList *module_search_paths_ptr,
                      lldb::ModuleSP *old_module_sp_ptr,
                      bool *did_create_ptr) override;
 
     uint32_t
     FindProcesses (const lldb_private::ProcessInstanceInfoMatch &match_info,
                    lldb_private::ProcessInstanceInfoList &process_infos) override;

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

PlatformiOSSimulator::GetSymbolFile (const FileSpec &platform_file,
     {
         error.SetErrorString ("invalid platform file argument");
     }
     return error;
 }
 
 Error
 PlatformiOSSimulator::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)
 {
     // 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

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.h

Attach(lldb_private::ProcessAttachInfo &attach_info,
            lldb_private::Error &error);
 
     virtual lldb_private::Error
     GetFileWithUUID(const lldb_private::FileSpec &platform_file,
                     const lldb_private::UUID* uuid, lldb_private::FileSpec &local_file);
 
     lldb_private::Error
     GetSharedModule(const lldb_private::ModuleSpec &module_spec,
+                    lldb_private::Process* process,
                     lldb::ModuleSP &module_sp,
                     const lldb_private::FileSpecList *module_search_paths_ptr,
                     lldb::ModuleSP *old_module_sp_ptr,
-                    bool *did_create_ptr);
+                    bool *did_create_ptr) override;
 
     virtual bool
     GetSupportedArchitectureAtIndex(uint32_t idx, lldb_private::ArchSpec &arch);
 
     virtual void
     GetStatus(lldb_private::Stream &strm);
 
     // Local debugging not yet supported

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp

PlatformWindows::GetFileWithUUID (const FileSpec &platform_file,
 
     // Default to the local case
     local_file = platform_file;
     return Error();
 }
 
 Error
 PlatformWindows::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)
 {
     Error error;
     module_sp.reset();
 
     if (IsRemote())
     {
         // If we have a remote platform always, let it try and locate
         // the shared module first.
         if (m_remote_platform_sp)
         {
             error = m_remote_platform_sp->GetSharedModule (module_spec,
+                                                           process,
                                                            module_sp,
                                                            module_search_paths_ptr,
                                                            old_module_sp_ptr,
                                                            did_create_ptr);
         }
     }
 
     if (!module_sp)
     {
         // Fall back to the local platform and find the file locally
         error = Platform::GetSharedModule (module_spec,
+                                           process,
                                            module_sp,
                                            module_search_paths_ptr,
                                            old_module_sp_ptr,
                                            did_create_ptr);
     }
     if (module_sp)
         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
     return error;

lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 PlatformRemoteGDBServer::GetModuleSpec (const FileSpec& module_file_spec,
                                         const ArchSpec& arch,
                                         ModuleSpec &module_spec)
 {
     Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
 
     const auto module_path = module_file_spec.GetPath ();
 
-    StringExtractorGDBRemote response;
-    if (!m_gdb_client.GetModuleInfo (module_path.c_str (), arch, response))
+    if (!m_gdb_client.GetModuleInfo (module_file_spec, arch, module_spec))
     {
         if (log)
             log->Printf ("PlatformRemoteGDBServer::%s - failed to get module info for %s:%s",
                          __FUNCTION__, module_path.c_str (), arch.GetTriple ().getTriple ().c_str ());
         return false;
     }
 
-    std::string name;
-    std::string value;
-    bool success;
-    StringExtractor extractor;
-
-    module_spec.Clear ();
-    module_spec.GetFileSpec () = module_file_spec;
-
-    while (response.GetNameColonValue (name, value))
-    {
-        if (name == "uuid" || name == "md5")
-        {
-            extractor.GetStringRef ().swap (value);
-            extractor.SetFilePos (0);
-            extractor.GetHexByteString (value);
-            module_spec.GetUUID().SetFromCString (value.c_str(), value.size() / 2);
-        }
-        else if (name == "triple")
-        {
-            extractor.GetStringRef ().swap (value);
-            extractor.SetFilePos (0);
-            extractor.GetHexByteString (value);
-            module_spec.GetArchitecture().SetTriple (value.c_str ());
-        }
-        else if (name == "file_offset")
-        {
-            const auto ival = StringConvert::ToUInt64 (value.c_str (), 0, 16, &success);
-            if (success)
-                module_spec.SetObjectOffset (ival);
-        }
-        else if (name == "file_size")
-        {
-            const auto ival = StringConvert::ToUInt64 (value.c_str (), 0, 16, &success);
-            if (success)
-                module_spec.SetObjectSize (ival);
-        }
-        else if (name == "file_path")
-        {
-            extractor.GetStringRef ().swap (value);
-            extractor.SetFilePos (0);
-            extractor.GetHexByteString (value);
-            module_spec.GetFileSpec () = FileSpec (value.c_str(), false);
-        }
-    }
-
     if (log)
     {
         StreamString stream;
         module_spec.Dump (stream);
         log->Printf ("PlatformRemoteGDBServer::%s - got module info for (%s:%s) : %s",
                      __FUNCTION__, module_path.c_str (), arch.GetTriple ().getTriple ().c_str (), stream.GetString ().c_str ());
     }
 

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h

public:
         /// Writes generic floating point registers into the specified buffer.
         Error
         WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size);
 
         /// Writes the specified register set into the specified buffer.
         /// For instance, the extended floating-point register set.
         Error
         WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset);
-        
+        Error
+        GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec) override;
+
     protected:
         // ---------------------------------------------------------------------
         // NativeProcessProtocol protected interface
         // ---------------------------------------------------------------------
         Error
         GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) override;
 
     private:

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #ifndef LLDB_CONFIGURATION_BUILDANDINTEGRATION
 #define PTRACE(req, pid, addr, data, data_size, error) \
     PtraceWrapper((req), (pid), (addr), (data), (data_size), (error), #req, __FILE__, __LINE__)
 #else
 #define PTRACE(req, pid, addr, data, data_size, error) \
     PtraceWrapper((req), (pid), (addr), (data), (data_size), (error))
 #endif
 
-// Private bits we only need internally.
-namespace
-{
-    using namespace lldb;
-    using namespace lldb_private;
+using namespace llvm;
 
+// Private bits we only need internally.
+namespace
+{
     static void * const EXIT_OPERATION = nullptr;
 
     const UnixSignals&
     GetUnixSignals ()
     {
         static process_linux::LinuxSignals signals;
         return signals;
     }
#endif
     void
     DetachOperation::Execute(NativeProcessLinux *monitor)
     {
         PTRACE(PTRACE_DETACH, m_tid, nullptr, 0, 0, m_error);
     }
 
 }
 
-using namespace lldb_private;
-
 // Simple helper function to ensure flags are enabled on the given file
 // descriptor.
 static bool
 EnsureFDFlags(int fd, int flags, Error &error)
 {
     int status;
 
     if ((status = fcntl(fd, F_GETFL)) == -1)
NativeProcessLinux::RequestThreadStop (const lldb::pid_t pid, const lldb::tid_t tid)
     {
         err.SetErrorToErrno ();
         if (log)
             log->Printf ("NativeProcessLinux::%s tgkill(%" PRIu64 ", %" PRIu64 ", SIGSTOP) failed: %s", __FUNCTION__, pid, tid, err.AsCString ());
     }
 
     return err;
 }
+
+Error
+NativeProcessLinux::GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec)
+{
+    char maps_file_name[32];
+    snprintf(maps_file_name, sizeof(maps_file_name), "/proc/%" PRIu64 "/maps", GetID());
+
+    FileSpec maps_file_spec(maps_file_name, false);
+    if (!maps_file_spec.Exists()) {
+        file_spec.Clear();
+        return Error("/proc/%" PRIu64 "/maps file doesn't exists!", GetID());
+    }
+
+    FileSpec module_file_spec(module_path, true);
+
+    std::ifstream maps_file(maps_file_name);
+    std::string maps_data_str((std::istreambuf_iterator<char>(maps_file)), std::istreambuf_iterator<char>());
+    StringRef maps_data(maps_data_str.c_str());
+
+    while (!maps_data.empty())
+    {
+        StringRef maps_row;
+        std::tie(maps_row, maps_data) = maps_data.split('\n');
+
+        SmallVector<StringRef, 16> maps_columns;
+        maps_row.split(maps_columns, StringRef(" "), -1, false);
+
+        if (maps_columns.size() >= 6)
+        {
+            file_spec.SetFile(maps_columns[5].str().c_str(), false);
+            if (file_spec.GetFilename() == module_file_spec.GetFilename())
+                return Error();
+        }
+    }
+
+    file_spec.Clear();
+    return Error("Module file (%s) not found in /proc/%" PRIu64 "/maps file!",
+                 module_file_spec.GetFilename().AsCString(), GetID());
+}

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

public:
 
     bool
     AvoidGPackets(ProcessGDBRemote *process);
 
     bool
     GetThreadExtendedInfoSupported();
 
     bool
-    GetModuleInfo (const char* module_path,
+    GetModuleInfo (const lldb_private::FileSpec& module_file_spec,
                    const lldb_private::ArchSpec& arch_spec,
-                   StringExtractorGDBRemote &response);
+                   lldb_private::ModuleSpec &module_spec);
 
 protected:
 
     PacketResult
     SendPacketAndWaitForResponseNoLock (const char *payload,
                                         size_t payload_length,
                                         StringExtractorGDBRemote &response);
 

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 // C++ Includes
 #include <sstream>
 
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Log.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamGDBRemote.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
if (GetSequenceMutex (locker, "Didn't get sequence mutex for QRestoreRegisterState."))
                 }
             }
         }
     }
     return false;
 }
 
 bool
-GDBRemoteCommunicationClient::GetModuleInfo (const char* module_path,
+GDBRemoteCommunicationClient::GetModuleInfo (const FileSpec& module_file_spec,
                                              const lldb_private::ArchSpec& arch_spec,
-                                             StringExtractorGDBRemote &response)
+                                             ModuleSpec &module_spec)
 {
-    if (!(module_path && module_path[0]))
+    std::string module_path = module_file_spec.GetPath ();
+    if (module_path.empty ())
         return false;
 
     StreamString packet;
     packet.PutCString("qModuleInfo:");
-    packet.PutBytesAsRawHex8(module_path, strlen(module_path));
+    packet.PutCStringAsRawHex8(module_path.c_str());
     packet.PutCString(";");
     const auto& tripple = arch_spec.GetTriple().getTriple();
     packet.PutBytesAsRawHex8(tripple.c_str(), tripple.size());
 
-    return SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success &&
-        !response.IsErrorResponse ();
+    StringExtractorGDBRemote response;
+    if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) != PacketResult::Success)
+        return false;
+
+    if (response.IsErrorResponse ())
+        return false;
+
+    std::string name;
+    std::string value;
+    bool success;
+    StringExtractor extractor;
+
+    module_spec.Clear ();
+    module_spec.GetFileSpec () = module_file_spec;
+
+    while (response.GetNameColonValue (name, value))
+    {
+        if (name == "uuid" || name == "md5")
+        {
+            extractor.GetStringRef ().swap (value);
+            extractor.SetFilePos (0);
+            extractor.GetHexByteString (value);
+            module_spec.GetUUID().SetFromCString (value.c_str(), value.size() / 2);
+        }
+        else if (name == "triple")
+        {
+            extractor.GetStringRef ().swap (value);
+            extractor.SetFilePos (0);
+            extractor.GetHexByteString (value);
+            module_spec.GetArchitecture().SetTriple (value.c_str ());
+        }
+        else if (name == "file_offset")
+        {
+            const auto ival = StringConvert::ToUInt64 (value.c_str (), 0, 16, &success);
+            if (success)
+                module_spec.SetObjectOffset (ival);
+        }
+        else if (name == "file_size")
+        {
+            const auto ival = StringConvert::ToUInt64 (value.c_str (), 0, 16, &success);
+            if (success)
+                module_spec.SetObjectSize (ival);
+        }
+        else if (name == "file_path")
+        {
+            extractor.GetStringRef ().swap (value);
+            extractor.SetFilePos (0);
+            extractor.GetHexByteString (value);
+            module_spec.GetFileSpec () = FileSpec (value.c_str(), false);
+        }
+    }
+
+    return true;
 }

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h

class GDBRemoteCommunicationServerCommon :
     public GDBRemoteCommunicationServer
 {
 public:
     GDBRemoteCommunicationServerCommon(const char *comm_name, const char *listener_name);
 
     virtual
     ~GDBRemoteCommunicationServerCommon();
 
-    bool
-    GetThreadSuffixSupported () override
-    {
-        return true;
-    }
-
-    //------------------------------------------------------------------
-    /// Launch a process with the current launch settings.
-    ///
-    /// This method supports running an lldb-gdbserver or similar
-    /// server in a situation where the startup code has been provided
-    /// with all the information for a child process to be launched.
-    ///
-    /// @return
-    ///     An Error object indicating the success or failure of the
-    ///     launch.
-    //------------------------------------------------------------------
-    virtual lldb_private::Error
-    LaunchProcess () = 0;
-
 protected:
     std::set<lldb::pid_t> m_spawned_pids;
     lldb_private::Mutex m_spawned_pids_mutex;
     lldb_private::ProcessLaunchInfo m_process_launch_info;
     lldb_private::Error m_process_launch_error;
     lldb_private::ProcessInstanceInfoList m_proc_infos;
     uint32_t m_proc_infos_index;
     bool m_thread_suffix_supported;
RegisterMemberFunctionHandler (StringExtractorGDBRemote::ServerPacketType packet_type,
                               [this, handler] (StringExtractorGDBRemote packet,
                                                lldb_private::Error &error,
                                                bool &interrupt,
                                                bool &quit)
                               {
                                   return (static_cast<T*>(this)->*handler) (packet);
                               });
     }
+
+    bool
+    GetThreadSuffixSupported () override
+    {
+        return true;
+    }
+
+    //------------------------------------------------------------------
+    /// Launch a process with the current launch settings.
+    ///
+    /// This method supports running an lldb-gdbserver or similar
+    /// server in a situation where the startup code has been provided
+    /// with all the information for a child process to be launched.
+    ///
+    /// @return
+    ///     An Error object indicating the success or failure of the
+    ///     launch.
+    //------------------------------------------------------------------
+    virtual lldb_private::Error
+    LaunchProcess () = 0;
+
+    virtual lldb_private::FileSpec
+    FindModuleFile (const std::string& module_path, const lldb_private::ArchSpec& arch);
 };
 
 #endif  // liblldb_GDBRemoteCommunicationServerCommon_h_

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

GDBRemoteCommunicationServerCommon::Handle_qModuleInfo (StringExtractorGDBRemote &packet)
 
     if (packet.GetChar() != ';')
         return SendErrorResponse (2);
 
     std::string triple;
     packet.GetHexByteString(triple);
     ArchSpec arch(triple.c_str());
 
-#ifdef __ANDROID__
-    const FileSpec module_path_spec = HostInfoAndroid::ResolveLibraryPath(module_path, arch);
-#else
-    const FileSpec module_path_spec(module_path.c_str(), true);
-#endif
-
+    const FileSpec module_path_spec = FindModuleFile(module_path, arch);
     const ModuleSpec module_spec(module_path_spec, arch);
 
     ModuleSpecList module_specs;
     if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0, module_specs))
         return SendErrorResponse (3);
 
     ModuleSpec matched_module_spec;
     if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
#endif
         if (proc_triple.isArch64Bit ())
             response.PutCString ("ptrsize:8;");
         else if (proc_triple.isArch32Bit ())
             response.PutCString ("ptrsize:4;");
         else if (proc_triple.isArch16Bit ())
             response.PutCString ("ptrsize:2;");
     }
 }
+
+FileSpec
+GDBRemoteCommunicationServerCommon::FindModuleFile(const std::string& module_path,
+                                                   const ArchSpec& arch)
+{
+#ifdef __ANDROID__
+    return HostInfoAndroid::ResolveLibraryPath(module_path, arch);
+#else
+    return FileSpec(module_path.c_str(), true);
+#endif
+}

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

protected:
     GetContinueThreadID () const { return m_continue_tid; }
 
     lldb_private::Error
     SetSTDIOFileDescriptor (int fd);
 
     static void
     STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len);
 
+    lldb_private::FileSpec
+    FindModuleFile (const std::string& module_path, const lldb_private::ArchSpec& arch) override;
+
 private:
     bool
     DebuggedProcessReaped (lldb::pid_t pid);
 
     static bool
     ReapDebuggedProcess (void *callback_baton,
                          lldb::pid_t pid,
                          bool exited,

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 #if defined(__linux__)
     if (log)
         log->Printf ("GDBRemoteCommunicationServerLLGS::%s clearing auxv buffer (previously %s)",
                      __FUNCTION__,
                      m_active_auxv_buffer_sp ? "was set" : "was not set");
     m_active_auxv_buffer_sp.reset ();
 #endif
 }
+
+FileSpec
+GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string& module_path,
+                                                 const ArchSpec& arch)
+{
+    if (m_debugged_process_sp)
+    {
+        FileSpec file_spec;
+        if (m_debugged_process_sp->GetLoadedModuleFileSpec(module_path.c_str(), file_spec).Success())
+        {
+            if (file_spec.Exists())
+                return file_spec;
+        }
+    }
+
+    return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch);
+}

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

public:
     // Override SetExitStatus so we can disconnect from the remote GDB server
     //----------------------------------------------------------------------
     bool
     SetExitStatus (int exit_status, const char *cstr) override;
 
     void
     SetUserSpecifiedMaxMemoryTransferSize (uint64_t user_specified_max);
 
+    bool
+    GetModuleSpec(const lldb_private::FileSpec& module_file_spec,
+                  const lldb_private::ArchSpec& arch,
+                  lldb_private::ModuleSpec &module_spec) override;
+
 protected:
     friend class ThreadGDBRemote;
     friend class GDBRemoteCommunicationClient;
     friend class GDBRemoteRegisterContext;
 
     //----------------------------------------------------------------------
     // Accessors
     //----------------------------------------------------------------------

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

if (user_specified_max != 0)
         }
         else
         {
             m_max_memory_size = user_specified_max;                 // user's packet size is probably fine
         }
     }
 }
 
+bool
+ProcessGDBRemote::GetModuleSpec(const FileSpec& module_file_spec,
+                                const ArchSpec& arch,
+                                ModuleSpec &module_spec)
+{
+    Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
+
+    if (!m_gdb_comm.GetModuleInfo (module_file_spec, arch, module_spec))
+    {
+        if (log)
+            log->Printf ("ProcessGDBRemote::%s - failed to get module info for %s:%s",
+                         __FUNCTION__, module_file_spec.GetPath ().c_str (),
+                         arch.GetTriple ().getTriple ().c_str ());
+        return false;
+    }
+
+    if (log)
+    {
+        StreamString stream;
+        module_spec.Dump (stream);
+        log->Printf ("ProcessGDBRemote::%s - got module info for (%s:%s) : %s",
+                     __FUNCTION__, module_file_spec.GetPath ().c_str (),
+                     arch.GetTriple ().getTriple ().c_str (), stream.GetString ().c_str ());
+    }
+
+    return true;
+}
+
 class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed
 {
 private:
     
 public:
     CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter) :
     CommandObjectParsed (interpreter,
                          "process plugin packet history",

lldb/trunk/source/Target/Platform.cpp

 //                return platform_sp;
 //        }
 //    }
 //    return PlatformSP();
 //}
 
 Error
 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 () && GetGlobalPlatformProperties ()->GetUseModuleCache ())
     {
         // Use caching only when talking to a remote platform.
-        if (GetCachedSharedModule (module_spec, module_sp))
+        if (GetCachedSharedModule (module_spec, process, module_sp))
         {
             if (did_create_ptr)
                 *did_create_ptr = true;
 
             return Error ();
         }
     }
     return ModuleList::GetSharedModule (module_spec, 

 Error
 Platform::LoadCachedExecutable (const ModuleSpec &module_spec,
                                 lldb::ModuleSP &module_sp,
                                 const FileSpecList *module_search_paths_ptr,
                                 Platform &remote_platform)
 {
     if (GetGlobalPlatformProperties ()->GetUseModuleCache ())
     {
-        if (GetCachedSharedModule (module_spec, module_sp))
+        if (GetCachedSharedModule (module_spec, nullptr, module_sp))
             return Error ();
     }
 
     return remote_platform.ResolveExecutable (module_spec,
                                               module_sp,
                                               module_search_paths_ptr);
 }
 
 bool
 Platform::GetCachedSharedModule (const ModuleSpec &module_spec,
+                                 Process* process,
                                  lldb::ModuleSP &module_sp)
 {
-    return (m_module_cache && GetModuleFromLocalCache (module_spec, module_sp));
+    return (m_module_cache && GetModuleFromLocalCache (module_spec, process, module_sp));
 }
 
 bool
 Platform::GetModuleFromLocalCache (const ModuleSpec& module_spec,
+                                   Process* process,
                                    lldb::ModuleSP &module_sp)
 {
     Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
 
-    // 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))
+            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))
             return false;
+    }
 
     // Check local cache for a module.
     auto error = m_module_cache->Get (GetModuleCacheRoot (),
                                       GetHostname (),
                                       resolved_module_spec,
                                       module_sp);
     if (error.Success ())
         return true;

lldb/trunk/source/Target/Process.cpp

 
 #include "lldb/Target/Process.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Expression/ClangUserExpression.h"
 #include "lldb/Expression/IRDynamicChecks.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
Process::GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type)
     pos = m_instrumentation_runtimes.find (type);
     if (pos == m_instrumentation_runtimes.end())
     {
         return InstrumentationRuntimeSP();
     }
     else
         return (*pos).second;
 }
+
+bool
+Process::GetModuleSpec(const FileSpec& module_file_spec,
+                       const ArchSpec& arch,
+                       ModuleSpec& module_spec)
+{
+    module_spec.Clear();
+    return false;
+}

lldb/trunk/source/Target/Target.cpp

if (!module_sp)
             }
 
             if (!module_sp)
             {
                 // The platform is responsible for finding and caching an appropriate
                 // module in the shared module cache.
                 if (m_platform_sp)
                 {
-                    error = m_platform_sp->GetSharedModule (module_spec, 
-                                                            module_sp, 
+                    error = m_platform_sp->GetSharedModule (module_spec,
+                                                            m_process_sp.get(),
+                                                            module_sp,
                                                             &GetExecutableSearchPaths(),
                                                             &old_module_sp,
                                                             &did_create_module);
                 }
                 else
                 {
                     error.SetErrorString("no platform is currently set");
                 }