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

2610

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...

2630

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

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

114

Do we need to call RegisterMemberFunctionHandler on Handle_qFileLoadAddress?

2610

+1

source/Utility/StringExtractorGDBRemote.h

64

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

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

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

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

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

s/INAV/INVA

[aidan.dodds]

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

docs/lldb-gdb-remote.txt

1001

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

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

415

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

Clarified documentation (big endian)

1001

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

include/lldb/Target/Process.h

3049

Done

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

415

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

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

Please set is_loaded = false.

4132

Could you check for return value of SendPacketAndWaitForResponse?

[tberghammer]

Address review comments

include/lldb/Host/common/NativeProcessProtocol.h

297

Done

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

4121

Done

4132

Done

[ovyalov]

LGTM

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
+//
+// RESPONSE
+//  <unsinged-hex64>: The load address of the file
+//  "FFFFFFFFFFFFFFFF": ((uint64_t)(-1)) The requested file isn't loaded
+//  "EXX" - for any 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

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)
+        {
+            return Error("Not implemented.");
+        }
+
     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;

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);
 
+    virtual Error
+    GetFileLoadAddress(const FileSpec& file, 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 
     // after it is discarded.)
     //
     // If you want to resume the process as a result of a resume action,
     // call RequestResume, don't call Resume directly.
     //------------------------------------------------------------------

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;
+        Error error = m_process->GetFileLoadAddress(entry.file_spec, load_addr);
+        if (error.Success() && load_addr != LLDB_INVALID_ADDRESS)
+            entry.base_addr = load_addr;
+    }
+
     return true;
 }
 
 
 bool
 DYLDRendezvous::FindMetadata(const char *name, PThreadField field, uint32_t& value)
 {
     Target& target = m_process->GetTarget();

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()); }

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)

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);

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
if (m_debugged_process_sp)
         m_debugged_process_sp->Terminate ();
         m_debugged_process_sp.reset ();
     }
 }
 
 void
 GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers()
 {
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C,
                                   &GDBRemoteCommunicationServerLLGS::Handle_C);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c,
                                   &GDBRemoteCommunicationServerLLGS::Handle_c);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_D,
                                   &GDBRemoteCommunicationServerLLGS::Handle_D);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_H,
                                   &GDBRemoteCommunicationServerLLGS::Handle_H);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_I,
                                   &GDBRemoteCommunicationServerLLGS::Handle_I);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_interrupt,
                                   &GDBRemoteCommunicationServerLLGS::Handle_interrupt);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_m,
                                   &GDBRemoteCommunicationServerLLGS::Handle_m);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_M,
                                   &GDBRemoteCommunicationServerLLGS::Handle_M);
     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);
+
+    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));

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, lldb::addr_t& load_addr) override;
+
 protected:
     friend class ThreadGDBRemote;
     friend class GDBRemoteCommunicationClient;
     friend class GDBRemoteRegisterContext;
 
     class GDBLoadedModuleInfoList;
 
     //----------------------------------------------------------------------

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, lldb::addr_t& load_addr)
+{
+    load_addr = LLDB_INVALID_ADDRESS;
+
+    std::string file_path = file.GetPath(false);
+    if (file_path.empty ())
+        return Error("Empty file path");
+
+    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("Fetching file load address from remote server failed");
+
+    if (!response.IsNormalResponse())
+        return Error("Fetching file load address from remote server returned an error");
+
+    load_addr = response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
+    return Error();
+}
+
 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),

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,

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;