Fetch object file load address if it isn't specified by the linker

[tberghammer]

Summary

Fetch object file load address if it isn't specified by the linker

On Android the load address for the linker isn't specified in the rendezvous data structure. This patch add a new GDB packet to fetch this information from the inferior based on /proc/<pid>/maps if it happens.

[labath]

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

2607 ↗

(On Diff #27791)

I am wondering whether we shouldn't thread the implementation of this down to NativeProcessLinux. Parsing of files in the proc filesystem is unlikely to be fruitful on non-linux systems...

2627 ↗

(On Diff #27791)

Nit: LLVM style guide recommends early exits to simplify things:

if (size() < 6)
  return true;
if (column[5] != file_name)
  return true;
...

[ovyalov]

Please see my comments.

include/lldb/Target/Process.h

3040 ↗

(On Diff #27791)

Nit - I'd rather call it GetModuleLoadAddress in order to underscore that it's not a regular file.

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

113 ↗

(On Diff #27791)

Do we need to call RegisterMemberFunctionHandler on Handle_qFileLoadAddress?

2607 ↗

(On Diff #27791)

+1

source/Utility/StringExtractorGDBRemote.h

64 ↗

(On Diff #27791)

Please update docs/lldb-gdb-remote.txt with new command description.

[tberghammer]

Move down logic for reading /proc/<pid>/maps into NativeProcessLinux

P.S.: The previous version of the patch was totally broken. I managed to upload a wrong version what wasn't even compiled.

[tberghammer]

include/lldb/Target/Process.h

3040 ↗

(On Diff #27791)

I intentionally named it a FileLoadAddress because the function (at least with the current implementation) can because to find the load address of any file mapped into the memory. I am not sure if we will use it for anything else but it might be useful.

[tberghammer]

Add documentation

[labath]

include/lldb/Target/Process.h

3040 ↗

(On Diff #27791)

If you go down that road you better specify the contract of the function much more precisely. For a program module (.so), the load address is a relatively clear concept (even though I am not sure if it is not possible to have the same module loaded twice at different addresses). However, regular files can be mapped into memory in strange ways:

• same file mapped multiple times
• a portion of a file mapped, but starting at a non-zero file offset

What will be the "load address" in these cases?

[tberghammer]

Improve documentation

[labath]

looks mostly good. I would just like to clarify a few things in the protocol...

docs/lldb-gdb-remote.txt

999 ↗

(On Diff #27806)

What is going to be the endianness of this value? I propose big endian, as that is what most packets seem to be using.

1001 ↗

(On Diff #27806)

I know F..F is not likely to be a valid load address, but what do you think about using one of the error codes to signify this condition? If it is not too much of a trouble to implement it, it sounds like a more reasonable solution.

include/lldb/Target/Process.h

3049 ↗

(On Diff #27806)

s/INAV/INVA

[aidan.dodds]

I added a few inlined comments, but overall this looks good to me.

docs/lldb-gdb-remote.txt

1001 ↗

(On Diff #27806)

An error code sounds good to me too as its less ambigous.

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

415 ↗

(On Diff #27806)

On some targets 0 can be a valid load address (Hexagon for example). I dont think this will cause problems in that case, as the call to GetFileLoadAddress() should return 0 in that case. But if your changing this peice of code it may be good to keep in mind.

[aidan.dodds]

I quickly tested this patch on linux and you were correct, it seems to fix some problems I was seeing with the dyld breakpoint not functioning properly. Thanks for that Tamas.

[tberghammer]

Address review comments

docs/lldb-gdb-remote.txt

999 ↗

(On Diff #27806)

Clarified documentation (big endian)

1001 ↗

(On Diff #27806)

Done.
(Use "E01" for file not loaded error.)

include/lldb/Target/Process.h

3049 ↗

(On Diff #27806)

Done

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

415 ↗

(On Diff #27806)

Thanks for the information. I believe this change won't cause any issue on hexagon but it is good to know.

[labath]

lgtm, thanks for fixing this :)

[ovyalov]

include/lldb/Host/common/NativeProcessProtocol.h

297 ↗

(On Diff #27871)

Nit - I think it's ok to make method pure virtual in order to follow existing style in NativeProcessProtocol

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

4121 ↗

(On Diff #27871)

Please set is_loaded = false.

4132 ↗

(On Diff #27871)

Could you check for return value of SendPacketAndWaitForResponse?

[tberghammer]

Address review comments

include/lldb/Host/common/NativeProcessProtocol.h

297 ↗

(On Diff #27871)

Done

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

4121 ↗

(On Diff #27871)

Done

4132 ↗

(On Diff #27871)

Done

[ovyalov]

LGTM

lldb/trunk/docs/lldb-gdb-remote.txt

 //
 // PRIORITY TO IMPLEMENT
 //  Low, this is mostly a convenience packet to avoid having to send all
 //  registers via a g packet. It should only be implemented if support
 //  for the QSaveRegisterState is added.
 //----------------------------------------------------------------------
 
 //----------------------------------------------------------------------
+// qFileLoadAddress:<file_path>
+//
+// BRIEF
+//  Get the load address of a memory mapped file.
+//  The load address is defined as the address of the first memory
+//  region what contains data mapped from the specified file.
+//
+// RESPONSE
+//  <unsinged-hex64> - Load address of the file in big endian encoding
+//  "E01" - the requested file isn't loaded
+//  "EXX" - for any other errors
+//
+// PRIORITY TO IMPLEMENT
+//  Low, required if dynamic linker don't fill in the load address of
+//  some object file in the rendezvous data structure.
+//----------------------------------------------------------------------
+
+//----------------------------------------------------------------------
 // qModuleInfo:<module_path>;<arch triple>
 //
 // BRIEF
 //  Get information for a module by given module path and architecture.
 //
 // RESPONSE
 //  "(uuid|md5):...;triple:...;file_offset:...;file_size...;"
 //  "EXX" - for any errors

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

 #define liblldb_NativeProcessProtocol_h_
 
 #include <vector>
 
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Host/Mutex.h"
+#include "llvm/ADT/StringRef.h"
 
 #include "NativeBreakpointList.h"
 #include "NativeWatchpointList.h"
 
 namespace lldb_private
 {
     class MemoryRegionInfo;
     class ResumeActionList;
public:
 
         // Called before termination of NativeProcessProtocol's instance.
         virtual void
         Terminate ();
 
         virtual Error
         GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec) = 0;
 
+        virtual Error
+        GetFileLoadAddress(const llvm::StringRef& file_name, lldb::addr_t& load_addr) = 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/Process.h

public:
     ///
     /// @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);
 
+    //------------------------------------------------------------------
+    /// Try to find the load address of a file.
+    /// The load address is defined as the address of the first memory
+    /// region what contains data mapped from the specified file.
+    ///
+    /// @param[in] file 
+    ///     The name of the file whose load address we are looking for
+    ///
+    /// @param[out] is_loaded
+    ///     \b True if the file is loaded into the memory and false
+    ///     otherwise.
+    ///
+    /// @param[out] load_addr
+    ///     The load address of the file if it is loaded into the
+    ///     processes address space, LLDB_INVALID_ADDRESS otherwise.
+    //------------------------------------------------------------------
+    virtual Error
+    GetFileLoadAddress(const FileSpec& file, bool& is_loaded, lldb::addr_t& load_addr)
+    {
+        return Error("Not supported");
+    }
+
 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/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

DYLDRendezvous::ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry)
     if (!(addr = ReadPointer(addr, &entry.next)))
         return false;
     
     if (!(addr = ReadPointer(addr, &entry.prev)))
         return false;
 
     entry.file_spec.SetFile(ReadStringFromMemory(entry.path_addr), false);
 
+    // The base_addr is not filled in for some case.
+    // Try to figure it out based on the load address of the object file.
+    if (entry.base_addr == 0)
+    {
+        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;
+    }
+
     return true;
 }
 
 
 bool
 DYLDRendezvous::FindMetadata(const char *name, PThreadField field, uint32_t& value)
 {
     Target& target = m_process->GetTarget();

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

public:
         DoStopIDBumped (uint32_t newBumpId) override;
 
         void
         Terminate () override;
 
         Error
         GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec) override;
 
+        Error
+        GetFileLoadAddress(const llvm::StringRef& file_name, lldb::addr_t& load_addr) override;
+
         // ---------------------------------------------------------------------
         // Interface used by NativeRegisterContext-derived classes.
         // ---------------------------------------------------------------------
         Error
         DoOperation(Operation* op);
 
         Error
         DoOperation(OperationUP op) { return DoOperation(op.get()); }

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

NativeProcessLinux::GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec)
     }
 
     file_spec.Clear();
     return Error("Module file (%s) not found in /proc/%" PRIu64 "/maps file!",
                  module_file_spec.GetFilename().AsCString(), GetID());
 }
 
 Error
+NativeProcessLinux::GetFileLoadAddress(const llvm::StringRef& file_name, lldb::addr_t& load_addr)
+{
+    load_addr = LLDB_INVALID_ADDRESS;
+    Error error = ProcFileReader::ProcessLineByLine (GetID (), "maps",
+        [&] (const std::string &line) -> bool
+        {
+            StringRef maps_row(line);
+ 
+            SmallVector<StringRef, 16> maps_columns;
+            maps_row.split(maps_columns, StringRef(" "), -1, false);
+ 
+            if (maps_columns.size() < 6)
+            {
+                // Return true to continue reading the proc file
+                return true;
+            }
+
+            if (maps_columns[5] == file_name)
+            {
+                StringExtractor addr_extractor(maps_columns[0].str().c_str());
+                load_addr = addr_extractor.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 
+
+                // Return false to stop reading the proc file further
+                return false;
+            }
+ 
+            // Return true to continue reading the proc file
+            return true;
+        });
+    return error; 
+}
+
+Error
 NativeProcessLinux::ResumeThread(
         lldb::tid_t tid,
         NativeThreadLinux::ResumeThreadFunction request_thread_resume_function,
         bool error_when_already_running)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
 
     if (log)

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

protected:
     Handle_D (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qThreadStopInfo (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qWatchpointSupportInfo (StringExtractorGDBRemote &packet);
 
+    PacketResult
+    Handle_qFileLoadAddress (StringExtractorGDBRemote &packet);
+
     void
     SetCurrentThreadID (lldb::tid_t tid);
 
     lldb::tid_t
     GetCurrentThreadID () const;
 
     void
     SetContinueThreadID (lldb::tid_t tid);

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

 #include "Utility/StringExtractorGDBRemote.h"
 #include "Utility/UriParser.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
+using namespace llvm;
 
 //----------------------------------------------------------------------
 // GDBRemote Errors
 //----------------------------------------------------------------------
 
 namespace
 {
     enum GDBRemoteServerError
GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers()
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_p,
                                   &GDBRemoteCommunicationServerLLGS::Handle_p);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_P,
                                   &GDBRemoteCommunicationServerLLGS::Handle_P);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qC);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qfThreadInfo,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo);
+    RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qFileLoadAddress,
+                                  &GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qProcessInfo,
                                   &GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo);
if (packet.GetChar() != ':')
         return SendErrorResponse(67);
 
     uint32_t num = m_debugged_process_sp->GetMaxWatchpoints();
     StreamGDBRemote response;
     response.Printf ("num:%d;", num);
     return SendPacketNoLock(response.GetData(), response.GetSize());
 }
 
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress (StringExtractorGDBRemote &packet)
+{
+    // Fail if we don't have a current process.
+    if (!m_debugged_process_sp ||
+            m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)
+        return SendErrorResponse(67);
+
+    packet.SetFilePos(strlen("qFileLoadAddress:"));
+    if (packet.GetBytesLeft() == 0)
+        return SendErrorResponse(68);
+
+    std::string file_name;
+    packet.GetHexByteString(file_name);
+
+    lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS;
+    Error error = m_debugged_process_sp->GetFileLoadAddress(file_name, file_load_address);
+    if (error.Fail())
+        return SendErrorResponse(69);
+
+    if (file_load_address == LLDB_INVALID_ADDRESS)
+        return SendErrorResponse(1); // File not loaded
+
+    StreamGDBRemote response;
+    response.PutHex64(file_load_address);
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+}
+
 void
 GDBRemoteCommunicationServerLLGS::FlushInferiorOutput ()
 {
     // If we're not monitoring an inferior's terminal, ignore this.
     if (!m_stdio_communication.IsConnected())
         return;
 
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));

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

public:
     void
     SetUserSpecifiedMaxMemoryTransferSize (uint64_t user_specified_max);
 
     bool
     GetModuleSpec(const FileSpec& module_file_spec,
                   const ArchSpec& arch,
                   ModuleSpec &module_spec) override;
 
-    virtual size_t
-    LoadModules () override;
+    size_t
+    LoadModules() override;
 
+    Error
+    GetFileLoadAddress(const FileSpec& file, bool& is_loaded, lldb::addr_t& load_addr) override;
+
 protected:
     friend class ThreadGDBRemote;
     friend class GDBRemoteCommunicationClient;
     friend class GDBRemoteRegisterContext;
 
     class GDBLoadedModuleInfoList;
 
     //----------------------------------------------------------------------

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

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();
 }
 
+Error
+ProcessGDBRemote::GetFileLoadAddress(const FileSpec& file, bool& is_loaded, lldb::addr_t& load_addr)
+{
+    is_loaded = false;
+    load_addr = LLDB_INVALID_ADDRESS;
+
+    std::string file_path = file.GetPath(false);
+    if (file_path.empty ())
+        return Error("Empty file name specified");
+
+    StreamString packet;
+    packet.PutCString("qFileLoadAddress:");
+    packet.PutCStringAsRawHex8(file_path.c_str());
+
+    StringExtractorGDBRemote response;
+    if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(), response, false) != GDBRemoteCommunication::PacketResult::Success)
+        return Error("Sending qFileLoadAddress packet failed");
+
+    if (response.IsErrorResponse())
+    {
+        if (response.GetError() == 1)
+        {
+            // The file is not loaded into the inferior
+            is_loaded = false;
+            load_addr = LLDB_INVALID_ADDRESS;
+            return Error();
+        }
+
+        return Error("Fetching file load address from remote server returned an error");
+    }
+
+    if (response.IsNormalResponse())
+    {
+        is_loaded = true;
+        load_addr = response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
+        return Error();
+    }
+
+    return Error("Unknown error happened during sending the load address packet");
+}
+
 class CommandObjectProcessGDBRemoteSpeedTest: public CommandObjectParsed
 {
 public:
     CommandObjectProcessGDBRemoteSpeedTest(CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "process plugin packet speed-test",
                              "Tests packet speeds of various sizes to determine the performance characteristics of the GDB remote connection. ",
                              NULL),

lldb/trunk/source/Utility/StringExtractorGDBRemote.h

enum ServerPacketType
         eServerPacketType_qLaunchGDBServer,
         eServerPacketType_qKillSpawnedProcess,
         eServerPacketType_qLaunchSuccess,
         eServerPacketType_qModuleInfo,
         eServerPacketType_qProcessInfoPID,
         eServerPacketType_qSpeedTest,
         eServerPacketType_qUserName,
         eServerPacketType_qGetWorkingDir,
+        eServerPacketType_qFileLoadAddress,
         eServerPacketType_QEnvironment,
         eServerPacketType_QLaunchArch,
         eServerPacketType_QSetDisableASLR,
         eServerPacketType_QSetDetachOnError,
         eServerPacketType_QSetSTDIN,
         eServerPacketType_QSetSTDOUT,
         eServerPacketType_QSetSTDERR,
         eServerPacketType_QSetWorkingDir,

lldb/trunk/source/Utility/StringExtractorGDBRemote.cpp

case 'q':
         case 'C':
             if (packet_size == 2)                               return eServerPacketType_qC;
             break;
 
         case 'E':
             if (PACKET_STARTS_WITH ("qEcho:"))                  return eServerPacketType_qEcho;
             break;
 
+        case 'F':
+            if (PACKET_STARTS_WITH ("qFileLoadAddress:"))       return eServerPacketType_qFileLoadAddress;
+            break;
+
         case 'G':
             if (PACKET_STARTS_WITH ("qGroupName:"))             return eServerPacketType_qGroupName;
             if (PACKET_MATCHES ("qGetWorkingDir"))              return eServerPacketType_qGetWorkingDir;
             if (PACKET_MATCHES ("qGetPid"))                     return eServerPacketType_qGetPid;
             if (PACKET_STARTS_WITH ("qGetProfileData;"))        return eServerPacketType_qGetProfileData;
             if (PACKET_MATCHES ("qGDBServerVersion"))           return eServerPacketType_qGDBServerVersion;
             break;