Understand absolute base addresses in ProcessGDBRemote::GetLoadedModuleList.

[sas]

Summary

This is useful when dealing with Windows remote that use only the
qXfer:libraries command which returns absolute base addresses, as
opposed to qXfer:libraries-svr4 which returns relative offsets for
module bases.

[tberghammer]

Looks good to me, but I don't know too much about the Windows stuff. I have a pending CL what will fix several issues related to absolute base addresses in the DynamicLoader. If it is something what is required on Windows side also I will try to upload it.

[clayborg]

Looks fine.

[sas]

Thanks for the reviews.

I'll take a look at your change when you upload it, Tamas. Do you think I can commit this in the meantime?

[tberghammer]

Yes, mine is effecting the ObjectFile plugins and the DynamicLoader plugins. I will try to upload it tomorrow

[sas]

Sounds good. Thanks.

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

protected:
     bool
     GetGDBServerRegisterInfo ();
 
     // Query remote GDBServer for a detailed loaded library list
     Error
     GetLoadedModuleList (GDBLoadedModuleInfoList &);
 
     lldb::ModuleSP
-    LoadModuleAtAddress (const FileSpec &file, lldb::addr_t base_addr);
+    LoadModuleAtAddress (const FileSpec &file, lldb::addr_t base_addr, bool value_is_offset);
 
 private:
     //------------------------------------------------------------------
     // For ProcessGDBRemote only
     //------------------------------------------------------------------
     static bool
     NewThreadNotifyBreakpointHit (void *baton,
                          StoppointCallbackContext *context,

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

public:
             m_has[e_has_base] = true;
         }
         bool get_base (lldb::addr_t & out) const
         {
             out = m_base;
             return m_has[e_has_base];
         }
 
+        void set_base_is_offset (bool is_offset)
+        {
+            m_base_is_offset = is_offset;
+        }
+        bool get_base_is_offset(bool & out) const
+        {
+            out = m_base_is_offset;
+            return m_has[e_has_base];
+        }
+
         void set_link_map (const lldb::addr_t addr)
         {
             m_link_map = addr;
             m_has[e_has_link_map] = true;
         }
         bool get_link_map (lldb::addr_t & out) const
         {
             out = m_link_map;
public:
         }
 
     protected:
 
         bool m_has[e_num];
         std::string m_name;
         lldb::addr_t m_link_map;
         lldb::addr_t m_base;
+        bool m_base_is_offset;
         lldb::addr_t m_dynamic;
     };
 
     GDBLoadedModuleInfoList ()
         : m_list ()
         , m_link_map (LLDB_INVALID_ADDRESS)
     {}
 
if (comm.GetQXferLibrariesSVR4ReadSupported ()) {
                 {
                     // the address of the link_map struct.
                     module.set_link_map(StringConvert::ToUInt64(value.data(), LLDB_INVALID_ADDRESS, 0));
                 }
                 else if (name == "l_addr")
                 {
                     // the displacement as read from the field 'l_addr' of the link_map struct.
                     module.set_base(StringConvert::ToUInt64(value.data(), LLDB_INVALID_ADDRESS, 0));
-                    
+                    // base address is always a displacement, not an absolute value.
+                    module.set_base_is_offset(true);
                 }
                 else if (name == "l_ld")
                 {
                     // the memory address of the libraries PT_DYAMIC section.
                     module.set_dynamic(StringConvert::ToUInt64(value.data(), LLDB_INVALID_ADDRESS, 0));
                 }
                 
                 return true; // Keep iterating over all properties of "library"
             });
 
             if (log)
             {
                 std::string name;
                 lldb::addr_t lm=0, base=0, ld=0;
+                bool base_is_offset;
 
                 module.get_name (name);
                 module.get_link_map (lm);
                 module.get_base (base);
+                module.get_base_is_offset (base_is_offset);
                 module.get_dynamic (ld);
 
-                log->Printf ("found (link_map:0x%08" PRIx64 ", base:0x%08" PRIx64 ", ld:0x%08" PRIx64 ", name:'%s')", lm, base, ld, name.c_str());
+                log->Printf ("found (link_map:0x%08" PRIx64 ", base:0x%08" PRIx64 "[%s], ld:0x%08" PRIx64 ", name:'%s')", lm, base, (base_is_offset ? "offset" : "absolute"), ld, name.c_str());
             }
 
             list.add (module);
             return true; // Keep iterating over all "library" elements in the root node
         });
 
         if (log)
             log->Printf ("found %" PRId32 " modules in total", (int) list.m_list.size());
if (comm.GetQXferLibrariesSVR4ReadSupported ()) {
             module.set_name(name.str());
 
             // The base address of a given library will be the address of its
             // first section. Most remotes send only one section for Windows
             // targets for example.
             const XMLNode &section = library.FindFirstChildElementWithName("section");
             llvm::StringRef address = section.GetAttributeValue("address");
             module.set_base(StringConvert::ToUInt64(address.data(), LLDB_INVALID_ADDRESS, 0));
+            // These addresses are absolute values.
+            module.set_base_is_offset(false);
 
             if (log)
             {
                 std::string name;
                 lldb::addr_t base = 0;
+                bool base_is_offset;
                 module.get_name (name);
                 module.get_base (base);
+                module.get_base_is_offset (base_is_offset);
 
-                log->Printf ("found (base:0x%08" PRIx64 ", name:'%s')", base, name.c_str());
+                log->Printf ("found (base:0x%08" PRIx64 "[%s], name:'%s')", base, (base_is_offset ? "offset" : "absolute"), name.c_str());
             }
 
             list.add (module);
             return true; // Keep iterating over all "library" elements in the root node
         });
 
         if (log)
             log->Printf ("found %" PRId32 " modules in total", (int) list.m_list.size());
     } else {
         return Error (0, ErrorType::eErrorTypeGeneric);
     }
 
     return Error();
 }
 
 lldb::ModuleSP
-ProcessGDBRemote::LoadModuleAtAddress (const FileSpec &file, lldb::addr_t base_addr)
+ProcessGDBRemote::LoadModuleAtAddress (const FileSpec &file, lldb::addr_t base_addr, bool value_is_offset)
 {
     Target &target = m_process->GetTarget();
     ModuleList &modules = target.GetImages();
     ModuleSP module_sp;
 
     bool changed = false;
 
     ModuleSpec module_spec (file, target.GetArchitecture());
     if ((module_sp = modules.FindFirstModule (module_spec)))
     {
-        module_sp->SetLoadAddress (target, base_addr, true, changed);
+        module_sp->SetLoadAddress (target, base_addr, value_is_offset, changed);
     }
     else if ((module_sp = target.GetSharedModule (module_spec)))
     {
-        module_sp->SetLoadAddress (target, base_addr, true, changed);
+        module_sp->SetLoadAddress (target, base_addr, value_is_offset, changed);
     }
 
     return module_sp;
 }
 
 size_t
 ProcessGDBRemote::LoadModules ()
 {
     using lldb_private::process_gdb_remote::ProcessGDBRemote;
 
     // request a list of loaded libraries from GDBServer
     GDBLoadedModuleInfoList module_list;
     if (GetLoadedModuleList (module_list).Fail())
         return 0;
 
     // get a list of all the modules
     ModuleList new_modules;
 
     for (GDBLoadedModuleInfoList::LoadedModuleInfo & modInfo : module_list.m_list)
     {
         std::string  mod_name;
         lldb::addr_t mod_base;
+        bool         mod_base_is_offset;
 
         bool valid = true;
         valid &= modInfo.get_name (mod_name);
         valid &= modInfo.get_base (mod_base);
+        valid &= modInfo.get_base_is_offset (mod_base_is_offset);
         if (!valid)
             continue;
 
         // hack (cleaner way to get file name only?) (win/unix compat?)
         size_t marker = mod_name.rfind ('/');
         if (marker == std::string::npos)
             marker = 0;
         else
             marker += 1;
 
         FileSpec file (mod_name.c_str()+marker, true);
-        lldb::ModuleSP module_sp = LoadModuleAtAddress (file, mod_base);
+        lldb::ModuleSP module_sp = LoadModuleAtAddress (file, mod_base, mod_base_is_offset);
 
         if (module_sp.get())
             new_modules.Append (module_sp);
     }
 
     if (new_modules.GetSize() > 0)
     {
         Target & target = m_target;