Add filepath to qModuleInfo packet

[tberghammer]

Summary

Add filepath to qModuleInfo packet

The file path is currently required on android because the executable only contain the name of the system libraries without their path. This CL add an extra field to the qModuleInfo packet to return the full path of a module and add logic to locate a shared module on android.

[ovyalov]

Please see my comments

source/Host/android/HostInfoAndroid.cpp

47 ↗

(On Diff #21616)

How we can handle application's native libraries loaded into zygote process?

If application loads a library via System.loadLibrary a load path might have a following format:

/data/app/com.google.ovyalov.ndktest-1/lib/x86/libprober.so

Depending on a target architecture x86 is replaced with arm64-v8a, armeabi, armeabi-v7a, mips, mips64 or x86_64.

As far as I can see from /proc/${PID}/environ there is no LD_LIBRARY_PATH variable - just LD_PRELOAD=libsigchain.so

88 ↗

(On Diff #21616)

Could you use FileSpec here instead of path concatenation?

FileSpec file_candidate(path);
file_candidate.AppendPathComponent(module_path);

[ovyalov]

http://stackoverflow.com/questions/5103443/how-to-check-what-shared-library-is-loaded-at-run-time

Potentially, we may add optional pid request field to qModuleInfo and then try either to call remotely dlopen(NULL, RTLD_NOW) in a zygote process (it might be tricky since this requires dl library loaded into a process) or parse /proc/$pid/maps

[tberghammer]

In D8221#138492, @ovyalov wrote:

http://stackoverflow.com/questions/5103443/how-to-check-what-shared-library-is-loaded-at-run-time

Potentially, we may add optional pid request field to qModuleInfo and then try either to call remotely dlopen(NULL, RTLD_NOW) in a zygote process (it might be tricky since this requires dl library loaded into a process) or parse /proc/$pid/maps

The problem with this approach is that qModuleInfo is usually called before starting the inferior (at least for native applications) so we have ho process to use for this purpose.

source/Host/android/HostInfoAndroid.cpp

47 ↗

(On Diff #21616)

I think (hope) when a library is loaded by System.loadLibrary then the debugger will capture the full path of the library, but currently a few feature is missing to try it out with a zygote child. If it isn't the case then we have to improve this function to handle that case also.

I think LD_LIBRARY_PATH is generally not used in android, but the bionic linker supports it so if somebody want to use it, then it is possible to do so. I can imagine a few case when you want to do it, so I would like to support it in lldb to be consistent with the library loader.

88 ↗

(On Diff #21616)

Done

lldb/trunk/include/lldb/Host/android/HostInfoAndroid.h

 {
 
 class HostInfoAndroid : public HostInfoLinux
 {
     friend class HostInfoBase;
 
   public:
     static FileSpec GetDefaultShell();
+    static FileSpec ResolveLibraryPath (const std::string& path, const ArchSpec& arch);
 
   protected:
     static void ComputeHostArchitectureSupport(ArchSpec &arch_32, ArchSpec &arch_64);
     static bool ComputeSupportExeDirectory(FileSpec &file_spec);
 };
 
 } // end of namespace lldb_private
 
 #endif // #ifndef lldb_Host_android_HostInfoAndroid_h_

lldb/trunk/source/Host/android/HostInfoAndroid.cpp

 //===-- HostInfoAndroid.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/android/HostInfoAndroid.h"
 #include "lldb/Host/linux/HostInfoLinux.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 
 using namespace lldb_private;
+using namespace llvm;
 
 void
 HostInfoAndroid::ComputeHostArchitectureSupport(ArchSpec &arch_32, ArchSpec &arch_64)
 {
     HostInfoLinux::ComputeHostArchitectureSupport(arch_32, arch_64);
 
     if (arch_32.IsValid())
     {
HostInfoAndroid::ComputeSupportExeDirectory(FileSpec &file_spec)
     return (bool)file_spec.GetDirectory();
 }
 
 FileSpec
 HostInfoAndroid::GetDefaultShell()
 {
     return FileSpec("/system/bin/sh", false);
 }
+
+FileSpec
+HostInfoAndroid::ResolveLibraryPath(const std::string& module_path, const ArchSpec& arch)
+{
+    static const char* const ld_library_path_separator = ":";
+    static const char* const default_lib32_path[] = {
+        "/vendor/lib",
+        "/system/lib",
+        nullptr
+    };
+    static const char* const default_lib64_path[] = {
+        "/vendor/lib64",
+        "/system/lib64",
+        nullptr
+    };
+
+    if (module_path.empty() || module_path[0] == '/')
+        return FileSpec(module_path.c_str(), true);
+
+    SmallVector<StringRef, 4> ld_paths;
+
+    if (const char* ld_library_path = ::getenv("LD_LIBRARY_PATH"))
+        StringRef(ld_library_path).split(ld_paths, StringRef(ld_library_path_separator), -1, false);
+
+    const char* const* default_lib_path = nullptr;
+    switch (arch.GetAddressByteSize())
+    {
+        case 4:
+            default_lib_path = default_lib32_path;
+            break;
+        case 8:
+            default_lib_path = default_lib64_path;
+            break;
+        default:
+            assert(false && "Unknown address byte size");
+            return FileSpec();
+    }
+
+    for(const char* const* it = default_lib_path; *it; ++it)
+        ld_paths.push_back(StringRef(*it));
+
+    for (const StringRef& path : ld_paths)
+    {
+        FileSpec file_candidate(path.str().c_str(), true);
+        file_candidate.AppendPathComponent(module_path.c_str());
+
+        if (file_candidate.Exists())
+            return file_candidate;
+    }
+
+    return FileSpec();
+}

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

while (response.GetNameColonValue (name, value))
                 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/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 
 // Project includes
 #include "ProcessGDBRemoteLog.h"
 #include "Utility/StringExtractorGDBRemote.h"
 
+#ifdef __ANDROID__
+#include "lldb/Host/android/HostInfoAndroid.h"
+#endif
+
 using namespace lldb;
 using namespace lldb_private;
 
 #ifdef __ANDROID__
     const static uint32_t g_default_packet_timeout_sec = 20; // seconds
 #else
     const static uint32_t g_default_packet_timeout_sec = 0; // not specified
 #endif

 GDBRemoteCommunicationServerCommon::Handle_qModuleInfo (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen ("qModuleInfo:"));
 
     std::string module_path;
     packet.GetHexByteStringTerminatedBy(module_path, ';');
     if (module_path.empty())
         return SendErrorResponse (1);
-    const FileSpec module_path_spec(module_path.c_str(), true);
 
     if (packet.GetChar() != ';')
         return SendErrorResponse (2);
 
     std::string triple;
     packet.GetHexByteString(triple);
-    const ModuleSpec module_spec(module_path_spec, ArchSpec(triple.c_str()));
+    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 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))
         return SendErrorResponse (4);
#endif
     }
     response.PutChar(';');
 
     const auto &module_arch = matched_module_spec.GetArchitecture();
     response.PutCString("triple:");
     response.PutCStringAsRawHex8( module_arch.GetTriple().getTriple().c_str());
     response.PutChar(';');
 
+    response.PutCString("file_path:");
+    response.PutCStringAsRawHex8(module_path_spec.GetPath().c_str());
+    response.PutChar(';');
     response.PutCString("file_offset:");
     response.PutHex64(file_offset);
     response.PutChar(';');
     response.PutCString("file_size:");
     response.PutHex64(file_size);
     response.PutChar(';');
 
     return SendPacketNoLock(response.GetData(), response.GetSize());