Add absolute load address support for the DynamicLoader plugins

[tberghammer]

Summary

Add absolute load address support for the DynamicLoader plugins

The POSIX linker generally reports the load bias for the loaded
libraries but in some case it is useful to handle a library based on
absolute load address. Example use cases:

• Windows linker uses absolute addresses
• Library list came from different source (e.g. /proc/<pid>/maps)

[clayborg]

Looks good.

lldb/trunk/include/lldb/Target/DynamicLoader.h

protected:
     /// @param module The module to traverse.
     ///
     /// @param link_map_addr The virtual address of the link map for the @p module.
     ///
     /// @param base_addr The virtual base address @p module is loaded at.
     virtual void
     UpdateLoadedSections(lldb::ModuleSP module,
                          lldb::addr_t link_map_addr,
-                         lldb::addr_t base_addr);
+                         lldb::addr_t base_addr,
+                         bool base_addr_is_offset);
 
     // Utility method so base classes can share implementation of UpdateLoadedSections
     void
     UpdateLoadedSectionsCommon(lldb::ModuleSP module,
-                               lldb::addr_t base_addr);
+                               lldb::addr_t base_addr,
+                               bool base_addr_is_offset);
 
     /// Removes the loaded sections from the target in @p module.
     ///
     /// @param module The module to traverse.
     virtual void
     UnloadSections(const lldb::ModuleSP module);
 
     // Utility method so base classes can share implementation of UnloadSections
     void
     UnloadSectionsCommon(const lldb::ModuleSP module);
 
     /// Locates or creates a module given by @p file and updates/loads the
     /// resulting module at the virtual base address @p base_addr.
-    lldb::ModuleSP
-    LoadModuleAtAddress(const lldb_private::FileSpec &file, lldb::addr_t link_map_addr, lldb::addr_t base_addr);
+    virtual lldb::ModuleSP
+    LoadModuleAtAddress(const lldb_private::FileSpec &file,
+                        lldb::addr_t link_map_addr,
+                        lldb::addr_t base_addr,
+                        bool base_addr_is_offset);
 
     const lldb_private::SectionList *
     GetSectionListFromModule(const lldb::ModuleSP module) const;
 
     // Read an unsigned int of the given size from memory at the given addr.
     // Return -1 if the read fails, otherwise return the result as an int64_t.
     int64_t
     ReadUnsignedIntWithSizeInBytes(lldb::addr_t addr, int size_in_bytes);

lldb/trunk/source/Core/DynamicLoader.cpp

if (executable.get())
                 }
             }
         }
     }
     return executable;
 }
 
 void
-DynamicLoader::UpdateLoadedSections(ModuleSP module, addr_t link_map_addr, addr_t base_addr)
+DynamicLoader::UpdateLoadedSections(ModuleSP module,
+                                    addr_t link_map_addr,
+                                    addr_t base_addr,
+                                    bool base_addr_is_offset)
 {
-    UpdateLoadedSectionsCommon(module, base_addr);
+    UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
 }
 
 void
-DynamicLoader::UpdateLoadedSectionsCommon(ModuleSP module, addr_t base_addr)
+DynamicLoader::UpdateLoadedSectionsCommon(ModuleSP module,
+                                          addr_t base_addr,
+                                          bool base_addr_is_offset)
 {
     bool changed;
-    const bool base_addr_is_offset = true;
     module->SetLoadAddress(m_process->GetTarget(), base_addr, base_addr_is_offset, changed);
 }
 
 void
 DynamicLoader::UnloadSections(const ModuleSP module)
 {
     UnloadSectionsCommon(module);
 }
if (module.get())
         {
             sections = obj_file->GetSectionList();
         }
     }
     return sections;
 }
 
 ModuleSP
-DynamicLoader::LoadModuleAtAddress(const FileSpec &file, addr_t link_map_addr, addr_t base_addr)
+DynamicLoader::LoadModuleAtAddress(const FileSpec &file,
+                                   addr_t link_map_addr,
+                                   addr_t base_addr,
+                                   bool base_addr_is_offset)
 {
     Target &target = m_process->GetTarget();
     ModuleList &modules = target.GetImages();
     ModuleSP module_sp;
 
     ModuleSpec module_spec (file, target.GetArchitecture());
     if ((module_sp = modules.FindFirstModule (module_spec)))
     {
-        UpdateLoadedSections(module_sp, link_map_addr, base_addr);
+        UpdateLoadedSections(module_sp, link_map_addr, base_addr, base_addr_is_offset);
     }
     else if ((module_sp = target.GetSharedModule(module_spec)))
     {
-        UpdateLoadedSections(module_sp, link_map_addr, base_addr);
+        UpdateLoadedSections(module_sp, link_map_addr, base_addr, base_addr_is_offset);
     }
     else
     {
-        // Try to fetch the load address of the file from the process. It can be different from the
-        // address reported by the linker in case of a file with fixed load address because the
-        // linker reports the bias between the load address specified in the file and the actual
-        // load address it loaded the file.
+        if (base_addr_is_offset)
+        {
+            // Try to fetch the load address of the file from the process as we need absolute load
+            // address to read the file out of the memory instead of a load bias.
             bool is_loaded;
             lldb::addr_t load_addr;
             Error error = m_process->GetFileLoadAddress(file, is_loaded, load_addr);
-        if (error.Fail() || !is_loaded)
-            load_addr = base_addr;
+            if (error.Success() && is_loaded)
+                base_addr = load_addr;
+        }
 
-        if ((module_sp = m_process->ReadModuleFromMemory(file, load_addr)))
+        if ((module_sp = m_process->ReadModuleFromMemory(file, base_addr)))
         {
-            UpdateLoadedSections(module_sp, link_map_addr, base_addr);
+            UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
             target.GetImages().AppendIfNeeded(module_sp);
         }
     }
 
     return module_sp;
 }
 
 int64_t

lldb/trunk/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h

protected:
     /// @param module The module to traverse.
     ///
     /// @param link_map_addr The virtual address of the link map for the @p module.
     ///
     /// @param base_addr The virtual base address @p module is loaded at.
     void
     UpdateLoadedSections(lldb::ModuleSP module,
                          lldb::addr_t link_map_addr,
-                         lldb::addr_t base_addr);
+                         lldb::addr_t base_addr,
+                         bool base_addr_is_offset) override;
 
     /// Removes the loaded sections from the target in @p module.
     ///
     /// @param module The module to traverse.
     void
     UnloadSections(const lldb::ModuleSP module);
 
     /// Locates or creates a module given by @p file and updates/loads the
     /// resulting module at the virtual base address @p base_addr.
     lldb::ModuleSP
-    LoadModuleAtAddress(const lldb_private::FileSpec &file, lldb::addr_t link_map_addr, lldb::addr_t base_addr);
+    LoadModuleAtAddress(const lldb_private::FileSpec &file,
+                        lldb::addr_t link_map_addr,
+                        lldb::addr_t base_addr,
+                        bool base_addr_is_offset) override;
 
     /// Callback routine invoked when we hit the breakpoint on process entry.
     ///
     /// This routine is responsible for resolving the load addresses of all
     /// dependent modules required by the inferior and setting up the rendezvous
     /// breakpoint.
     static bool
     EntryBreakpointHit(void *baton, 

lldb/trunk/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

DynamicLoaderHexagonDYLD::DidAttach()
     m_process->SetCanInterpretFunctionCalls(true);
 
     // Add the current executable to the module list
     ModuleList module_list;
     module_list.Append(executable);
 
     // Map the loaded sections of this executable
     if ( load_offset != LLDB_INVALID_ADDRESS )
-        UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset);
+        UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
 
     // AD: confirm this?
     // Load into LLDB all of the currently loaded executables in the stub
     LoadAllCurrentModules();
 
     // AD: confirm this?
     // Callback for the target to give it the loaded module list
     m_process->GetTarget().ModulesDidLoad(module_list);

 //AD: Needs to be updated?
 Error
 DynamicLoaderHexagonDYLD::CanLoadImage()
 {
     return Error();
 }
 
 void
-DynamicLoaderHexagonDYLD::UpdateLoadedSections(ModuleSP module, addr_t link_map_addr, addr_t base_addr)
+DynamicLoaderHexagonDYLD::UpdateLoadedSections(ModuleSP module,
+                                               addr_t link_map_addr,
+                                               addr_t base_addr,
+                                               bool base_addr_is_offset)
 {
     Target &target = m_process->GetTarget();
     const SectionList *sections = GetSectionListFromModule(module);
 
     assert(sections && "SectionList missing from loaded module.");
 
     m_loaded_modules[module] = link_map_addr;
 
DynamicLoaderHexagonDYLD::RefreshModules()
     if (m_rendezvous.ModulesDidLoad()) 
     {
         ModuleList new_modules;
 
         E = m_rendezvous.loaded_end();
         for (I = m_rendezvous.loaded_begin(); I != E; ++I)
         {
             FileSpec file(I->path.c_str(), true);
-            ModuleSP module_sp = LoadModuleAtAddress(file, I->link_addr, I->base_addr);
+            ModuleSP module_sp = LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
             if (module_sp.get())
             {
                 loaded_modules.AppendIfNeeded( module_sp );
                 new_modules.Append(module_sp);
             }
             
             if (log)
             {
DynamicLoaderHexagonDYLD::LoadAllCurrentModules()
     ModuleSP executable = GetTargetExecutable();
     m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
 
 
     for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I)
     {
         const char *module_path = I->path.c_str();
         FileSpec file(module_path, false);
-        ModuleSP module_sp = LoadModuleAtAddress(file, I->link_addr, I->base_addr);
+        ModuleSP module_sp = LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
         if (module_sp.get())
         {
             module_list.Append(module_sp);
         }
         else
         {
             Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
             if (log)
                 log->Printf("DynamicLoaderHexagonDYLD::%s failed loading module %s at 0x%" PRIx64,
                             __FUNCTION__, module_path, I->base_addr);
         }
     }
 
     m_process->GetTarget().ModulesDidLoad(module_list);
 }
 
 /// Helper for the entry breakpoint callback.  Resolves the load addresses
 /// of all dependent modules.
 ModuleSP
-DynamicLoaderHexagonDYLD::LoadModuleAtAddress(const FileSpec &file, addr_t link_map_addr, addr_t base_addr)
+DynamicLoaderHexagonDYLD::LoadModuleAtAddress(const FileSpec &file,
+                                              addr_t link_map_addr,
+                                              addr_t base_addr,
+                                              bool base_addr_is_offset)
 {
     Target &target = m_process->GetTarget();
     ModuleList &modules = target.GetImages();
     ModuleSP module_sp;
 
     ModuleSpec module_spec (file, target.GetArchitecture());
 
     // check if module is currently loaded
     if ((module_sp = modules.FindFirstModule (module_spec))) 
     {
-        UpdateLoadedSections(module_sp, link_map_addr, base_addr);
+        UpdateLoadedSections(module_sp, link_map_addr, base_addr, true);
     }
     // try to load this module from disk
     else if ((module_sp = target.GetSharedModule(module_spec))) 
     {
-        UpdateLoadedSections(module_sp, link_map_addr, base_addr);
+        UpdateLoadedSections(module_sp, link_map_addr, base_addr, true);
     }
 
     return module_sp;
 }
 
 /// Computes a value for m_load_offset returning the computed address on
 /// success and LLDB_INVALID_ADDRESS on failure.
 addr_t

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h

protected:
     /// Rendezvous breakpoint.
     lldb::break_id_t m_dyld_bid;
 
     /// Loaded module list. (link map for each module)
     std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>> m_loaded_modules;
 
     /// Enables a breakpoint on a function called by the runtime
     /// linker each time a module is loaded or unloaded.
-    void
+    virtual void
     SetRendezvousBreakpoint();
 
     /// Callback routine which updates the current list of loaded modules based
     /// on the information supplied by the runtime linker.
     static bool
     RendezvousBreakpointHit(void *baton, 
                             lldb_private::StoppointCallbackContext *context, 
                             lldb::user_id_t break_id, 
                             lldb::user_id_t break_loc_id);
     
     /// Helper method for RendezvousBreakpointHit.  Updates LLDB's current set
     /// of loaded modules.
     void
     RefreshModules();
 
     /// Updates the load address of every allocatable section in @p module.
     ///
     /// @param module The module to traverse.
     ///
     /// @param link_map_addr The virtual address of the link map for the @p module.
     ///
     /// @param base_addr The virtual base address @p module is loaded at.
-    virtual void
+    void
     UpdateLoadedSections(lldb::ModuleSP module,
                          lldb::addr_t link_map_addr,
-                         lldb::addr_t base_addr);
+                         lldb::addr_t base_addr,
+                         bool base_addr_is_offset) override;
 
     /// Removes the loaded sections from the target in @p module.
     ///
     /// @param module The module to traverse.
-    virtual void
-    UnloadSections(const lldb::ModuleSP module);
+    void
+    UnloadSections(const lldb::ModuleSP module) override;
 
     /// Resolves the entry point for the current inferior process and sets a
     /// breakpoint at that address.
     void
     ProbeEntry();
 
     /// Callback routine invoked when we hit the breakpoint on process entry.
     ///
     /// This routine is responsible for resolving the load addresses of all
     /// dependent modules required by the inferior and setting up the rendezvous
     /// breakpoint.
     static bool
     EntryBreakpointHit(void *baton, 
                        lldb_private::StoppointCallbackContext *context, 
                        lldb::user_id_t break_id, 
                        lldb::user_id_t break_loc_id);
 
     /// Helper for the entry breakpoint callback.  Resolves the load addresses
     /// of all dependent modules.
-    void
+    virtual void
     LoadAllCurrentModules();
 
     /// Computes a value for m_load_offset returning the computed address on
     /// success and LLDB_INVALID_ADDRESS on failure.
     lldb::addr_t
     ComputeLoadOffset();
 
     /// Computes a value for m_entry_point returning the computed address on

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

if (rebase_exec)
 
         module_list.Append(executable_sp);
         if (log)
             log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " added executable '%s' to module load list",
                          __FUNCTION__,
                          m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID,
                          executable_sp->GetFileSpec().GetPath().c_str ());
 
-        UpdateLoadedSections(executable_sp, LLDB_INVALID_ADDRESS, load_offset);
+        UpdateLoadedSections(executable_sp, LLDB_INVALID_ADDRESS, load_offset, true);
 
         // When attaching to a target, there are two possible states:
         // (1) We already crossed the entry point and therefore the rendezvous
         //     structure is ready to be used and we can load the list of modules
         //     and place the rendezvous breakpoint.
         // (2) We didn't cross the entry point yet, so these structures are not
         //     ready; we should behave as if we just launched the target and
         //     call ProbeEntry(). This will place a breakpoint on the entry
DynamicLoaderPOSIXDYLD::DidLaunch()
 
     executable = GetTargetExecutable();
     load_offset = ComputeLoadOffset();
 
     if (executable.get() && load_offset != LLDB_INVALID_ADDRESS)
     {
         ModuleList module_list;
         module_list.Append(executable);
-        UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset);
+        UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
 
         if (log)
             log->Printf ("DynamicLoaderPOSIXDYLD::%s about to call ProbeEntry()", __FUNCTION__);
         ProbeEntry();
 
         m_process->GetTarget().ModulesDidLoad(module_list);
     }
 }

 
 Error
 DynamicLoaderPOSIXDYLD::CanLoadImage()
 {
     return Error();
 }
 
 void
-DynamicLoaderPOSIXDYLD::UpdateLoadedSections(ModuleSP module, addr_t link_map_addr, addr_t base_addr)
+DynamicLoaderPOSIXDYLD::UpdateLoadedSections(ModuleSP module,
+                                             addr_t link_map_addr,
+                                             addr_t base_addr,
+                                             bool base_addr_is_offset)
 {
     m_loaded_modules[module] = link_map_addr;
-
-    UpdateLoadedSectionsCommon(module, base_addr);
+    UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
 }
 
 void
 DynamicLoaderPOSIXDYLD::UnloadSections(const ModuleSP module)
 {
     m_loaded_modules.erase(module);
 
     UnloadSectionsCommon(module);
DynamicLoaderPOSIXDYLD::RefreshModules()
 
     if (m_rendezvous.ModulesDidLoad()) 
     {
         ModuleList new_modules;
 
         E = m_rendezvous.loaded_end();
         for (I = m_rendezvous.loaded_begin(); I != E; ++I)
         {
-            ModuleSP module_sp = LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr);
+            ModuleSP module_sp = LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr, true);
             if (module_sp.get())
             {
                 loaded_modules.AppendIfNeeded(module_sp);
                 new_modules.Append(module_sp);
             }
         }
         m_process->GetTarget().ModulesDidLoad(new_modules);
     }
     
     if (m_rendezvous.ModulesDidUnload())
     {
         ModuleList old_modules;
 
         E = m_rendezvous.unloaded_end();
         for (I = m_rendezvous.unloaded_begin(); I != E; ++I)
         {
             ModuleSpec module_spec{I->file_spec};
-            ModuleSP module_sp =
-                loaded_modules.FindFirstModule (module_spec);
+            ModuleSP module_sp = loaded_modules.FindFirstModule (module_spec);
 
             if (module_sp.get())
             {
                 old_modules.Append(module_sp);
                 UnloadSections(module_sp);
             }
         }
         loaded_modules.Remove(old_modules);
if (!m_rendezvous.Resolve())
         return;
     }
 
     // The rendezvous class doesn't enumerate the main module, so track
     // that ourselves here.
     ModuleSP executable = GetTargetExecutable();
     m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
 
-
     for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I)
     {
-        ModuleSP module_sp = LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr);
+        ModuleSP module_sp = LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr, true);
         if (module_sp.get())
         {
             module_list.Append(module_sp);
         }
         else
         {
             Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
             if (log)

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 {
     ModuleSP module_sp = GetModule();
     if (module_sp)
     {
         size_t num_loaded_sections = 0;
         SectionList *section_list = GetSectionList ();
         if (section_list)
         {
-            if (value_is_offset)
+            if (!value_is_offset)
             {
-                const size_t num_sections = section_list->GetSize();
-                size_t sect_idx = 0;
+                bool found_offset = false;
+                for (size_t i = 0, count = GetProgramHeaderCount(); i < count; ++i)
+                {
+                    const elf::ELFProgramHeader* header = GetProgramHeaderByIndex(i);
+                    if (header == nullptr)
+                        continue;
+
+                    if (header->p_type != PT_LOAD || header->p_offset != 0)
+                        continue;
+                    
+                    value = value - header->p_vaddr;
+                    found_offset = true;
+                    break;
+                }
+                if (!found_offset)
+                    return false;
+            }
+
 
-                for (sect_idx = 0; sect_idx < num_sections; ++sect_idx)
-                {
-                    // Iterate through the object file sections to find all
-                    // of the sections that have SHF_ALLOC in their flag bits.
-                    SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx));
-                    // if (section_sp && !section_sp->IsThreadSpecific())
-                    if (section_sp && section_sp->Test(SHF_ALLOC))
-                    {
-                        lldb::addr_t load_addr = section_sp->GetFileAddress() + value;
-                        
-                        // On 32-bit systems the load address have to fit into 4 bytes. The rest of
-                        // the bytes are the overflow from the addition.
-                        if (GetAddressByteSize() == 4)
-                            load_addr &= 0xFFFFFFFF;
 
-                        if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, load_addr))
-                            ++num_loaded_sections;
-                    }
-                }
-                return num_loaded_sections > 0;
-            }
-            else
-            {
-                // Not sure how to slide an ELF file given the base address
-                // of the ELF file in memory
-            }
-        }
-    }
-    return false; // If it changed
+    return false;
 }
 
 ByteOrder
 ObjectFileELF::GetByteOrder() const
 {
     if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
         return eByteOrderBig;
     if (m_header.e_ident[EI_DATA] == ELFDATA2LSB)