FreeBSD kernel debugging fixes

[bkoropoff]

Summary

This resolves issues I encountered when using lldb to symbolicate
FreeBSD kernel backtraces. The problems mostly centered around
FreeBSD kernel modules actually being relocatable (.o) ELF Files.

The major problems:

• Relocations were not being applied to the DWARF debug info despite there being code to do this. Several issues prevented it from working:
  • Relocations are computed at the same time as the symbol table, but in the case of split debug files, symbol table parsing always redirects to the primary object file, meaning that relocations would never be applied in the debug file.
  • There's actually no guarantee that the symbol table has been parsed yet when trying to parse debug information.
  • When actually applying relocations, it will segfault because the object files are not mapped with MAP_PRIVATE and PROT_WRITE.
• LLDB returned invalid results when performing ordinary address-to-symbol resolution. It turned out that the addresses specified in the section headers were all 0, so LLDB believed all the sections had overlapping "file addresses" and would sometimes return a symbol from the wrong section.

I rearranged some of the symbol table parsing code to ensure
relocations would get applied consistently and added manual calls to
make sure it happens before trying to use DWARF info, but it feels
kind of hacky. I'm open to suggestions for refactoring it.

I solved the file address problem by computing synthetic addresses for
the sections in object files so that they would not overlap in LLDB's
lookup maps.

With all these changes I'm able to successfully symbolicate backtraces
that pass through FreeBSD kernel modules. Let me know if there is a
better/cleaner way to achieve any of these fixes.

[clayborg]

Very close. See inlined comments.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

635–636

It would be nice to just call:

m_obj_file->PerformRelocationsIfNeeded();

If we change "void ObjectFileELF::PerformRelocations(lldb_private::Symtab *thetab)" to be "void ObjectFileELF::PerformRelocationsIfNeeded()", it can just call "m_symtab_ap.get()" to get the symbol table internally. I would rather not call ObjectFileElf::GetSymtab() as a way to perform relocations.

[bkoropoff]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

635–636

This will require changing the interface of ObjectFile, which I avoided. If that's OK, I'll add the method.

[clayborg]

So I found a lot more stuff. The inlined comments detail quite a few changes we should make. The ELF relocations can use a bit of cleanup. Let me know if anything is not clear.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

408

It would be nice to avoid mapping everything private with copy on write if we can get away with it. Maybe we can map everything as shared and read only, and then in ObjectFile::ReadSectionData(Section *...) we relocate a private copy if needed, else hand out the const bits we have? Since most ELF files don't require modifications, only object files..

We should switch this back to false, and then re-read with "true" below if needed as detailed in comment below.

424

We can improve this if statement to remap as private + read/write. Something like:

bool map_private = ELFHeader::NeedsRelocations(data_sp->GetBytes());

if (data_sp->GetByteSize() < length || map_private) {
  data_sp =
    DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset, map_private);

ELFHeader::NeedsRelocations would check the ELF header's e_type to see if it is llvm::ELF::ET_REL and return true. Does that make sense?

1817–1837

Move this as a static function in lldb_private::Section:

static bool Section::IsDebugSection(SectionType sect_type);

Also rename "Type" to "sect_type". Camel case if for types in LLDB

2814

rename "thetab" to "symtab"

2870–2871

When would this be used? Do your .o files for the kernel binaries have two separate files? You are going to apply relocations one .o file to the symbol table in another file?

2952–2955

So we probably want to perform relocations somewhere else, like when we parse the section headers for an ELF file. This seems fragile in that if no one accesses the symbol table for an ELF file we might end up handing out unrelocated section data. This relocation stuff should be moved. And the relocation of symbols should probably only happen when the symbol table is asked for. So we might need "m_relocated_sections" and "m_relocated_symtab". I know this is the way it was done before, but it seems error prone and we should fix this. It might be better to have lldb_private::Section objects know how to relocate themselves using its ObjectFile and the section would keep track if it has been relocated or not. ObjectFile has two ObjectFile::ReadSectionData(...) functions. Those functions could check if a Section has been relocate or not and call a new:

virtual void ObjectFile::RelocateSectionData(lldb_private::Section *section);

There are boolean bits available in lldb_private::Section (search for "m_executable" in Section.h).

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

221

This should be removed, see comments below about having lldb_private::Section objects tracking if they have been relocated or not.

297

Ditto.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

636

Actually I was thinking this code was in ObjectFileELF already. I missed that it was in SymbolFileDWARF.cpp. No one outside of the ObjectFile should have to worry about applying relocations before making calls into ObjectFile subclasses. This code should be removed and put into ObjectFile subclasses. Not sure where the best place is, but no one should have to worry about manually applying relocs.

[bkoropoff]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

408

Maybe we can map everything as shared and read only, and then in ObjectFile::ReadSectionData(Section *...) we relocate a private copy if needed, else hand out the const bits we have?

Isn't that re-implementing copy-on-write? Is there a particular reason not to let the OS handle it, like a platform where it's unusually expensive?

1817–1837

I realized I can just use the SHT_ALLOC bit to decide if a section needs a synthetic address, so I'll probably drop this entirely.

2870–2871

Yes, we have split debug info for kernel binaries. Debug info files have identical section ordering and symtab, except the main sections (e.g. .text) are set to type NOBITS and aren't repeated in the file.

Come to think of it, the existing logic seems wrong for normal executables/libraries where the symtab might be stripped entirely and only be present in the debug file (our main kernel binaries retain it, so it's in both). It seems the logic should be more like:

if (m_symtab_ap != nullptr)
    return m_symtab_ap.get();

ObjectFile *module_obj_file = module_sp->GetObjectFile();
if (module_obj_file && module_obj_file != this) {
    Symtab *tab = module_obj_file->GetSymtab();
    if (tab != nullptr)
        return tab;
}

// Rest of function ...

This will find it in one file or the other, but only parse one copy as desired.

2952–2955

Yeah, doing it just-in-time when reading the section seems cleaner.

[clayborg]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

408

As long as sending true still maps SHARED then this would be find. If it maps PRIVATE then multiple processes won't be able to share the pages... Not sure what the "true" or "false" turns into

1837

That would be fine too

2874

Not sure on the ramifications of your suggested change... Sounds good though, but it would change functionality. We definitely was to take the most complete symbol table...

[bkoropoff]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

408

It passes PRIVATE, but that's how you get copy-on-write. We don't want to share modifications.

[bkoropoff]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2952–2955

ReadSectionData takes const Section *section, so if I use a boolean member on Section I'll have to make it mutable.

[bkoropoff]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2952–2955

Actually, the methods themselves are const, so it's going to get ugly. Can I just make the methods and parameters non-const?

[bkoropoff]

Made changes according to feedback.

In particular, relocations are now applied just-in-time when reading
section data.

[bkoropoff]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2874

Since it's an unrelated change, I've held off for now.

[clayborg]

Very nice section auto relocate code. Just a few things to clean up and this will be good to go.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

408

I would still like this to be false to start off with, then we determine if we have an object file, and reread the data with "true" as mentioned in comments for line 424 below. Object files are so rare. If LLDB is used for symbolication where one machine is loading multiple instances of a file, we want this shared by default.

2948

Do symbols not need any relocation fixups anymore?

2953

We need to check if the section has already been relocated and return right away if it has. Otherwise we will apply the relocations many times.

source/Symbol/ObjectFile.cpp

508–509

So we either rename "RelocateSectionIfNeeded(...)" to "RelocateSection(...)", or we just call "RelocateSectionIfNeeded(section)" and let it do the check.

[bkoropoff]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

408

PRIVATE mmaps on any sane Unix system or FILE_MAP_COPY file maps on Windows provide copy-on-write behavior. All mappings of the same file share the same physical pages until a write occurs, at which point the writer transparently receives a private copy of the page. SHARED specifies that you want to share *modifications* with other mappings and the on-disk file. If you never write to the mapping (as with executables/dylibs), copies never occur, so the end behavior is the same.

2948

The symtab doesn't have relocations, but it's necessary to perform them. That's probably why the existing code did relocations immediately after parsing the symtab.

source/Symbol/ObjectFile.cpp

508–509

This way avoids an unnecessary function call, so I'll rename the method.

[clayborg]

Thanks for the explanation of the private vs shared, we can leave it as you have it. Just rename to RelocateSection and this will be good to go.

[bkoropoff]

Make changes according to feedback

[bkoropoff]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2814

That conflicts with a later local variable.

[bkoropoff]

Are there any more changes needed, or is this ready to go?

[bkoropoff]

Since I'm unfamiliar with the workflow here, is there anything else needed from me to land these patches?

[clayborg]

Verify you have commit priveleges, and then check in the sources with the following text in the SVN commit message:

Differential Revision: https://reviews.llvm.org/D38142

[bkoropoff]

Since I'm a first-time contributor, I definitely don't have commit privileges. Should I apply for them, or is someone else supposed to commit this for me?

[emaste]

In D38142#882374, @bkoropoff wrote:

Since I'm a first-time contributor, I definitely don't have commit privileges. Should I apply for them, or is someone else supposed to commit this for me?

Yes, for initial contributions someone typically commits them for you. Since this is prompted by work for FreeBSD I'm happy to take care of that if @clayborg doesn' do it first.

[bkoropoff]

In D38142#882408, @emaste wrote:

Yes, for initial contributions someone typically commits them for you. Since this is prompted by work for FreeBSD I'm happy to take care of that if @clayborg doesn' do it first.

Feel free to do so.

[emaste]

I realized I don't have my LLVM SVN creds on my laptop, so will commit this when I return home in a couple of days if it's still not done.

[emaste]

In D38142#882374, @bkoropoff wrote:

Since I'm a first-time contributor, I definitely don't have commit privileges. Should I apply for them, or is someone else supposed to commit this for me?

Thanks for the submission! I committed this as rL314672.

If you've got more work in the pipeline you might as well apply for commit access as described in https://llvm.org/docs/DeveloperPolicy.html

include/lldb/Core/Section.h

public:
   /// @param[in] data
   ///     Where to place the data, address byte size, and byte order
   ///
   /// @return
   ///     The number of bytes read from the section, or zero if the
   ///     section has no data or \a offset is not a valid offset
   ///     in this section.
   //------------------------------------------------------------------
-  lldb::offset_t GetSectionData(DataExtractor &data) const;
+  lldb::offset_t GetSectionData(DataExtractor &data);
 
   uint32_t GetLog2Align() { return m_log2align; }
 
   void SetLog2Align(uint32_t align) { m_log2align = align; }
 
   // Get the number of host bytes required to hold a target byte
   uint32_t GetTargetByteSize() const { return m_target_byte_size; }
 
+  bool IsRelocated() const { return m_relocated; }
+
+  void SetIsRelocated(bool b) { m_relocated = b; }
+
 protected:
   ObjectFile *m_obj_file;   // The object file that data for this section should
                             // be read from
   lldb::SectionType m_type; // The type of this section
   lldb::SectionWP m_parent_wp; // Weak pointer to parent section
   ConstString m_name;          // Name of this section
   lldb::addr_t m_file_addr; // The absolute file virtual address range of this
                             // section if m_parent == NULL,
bool m_fake : 1, // If true, then this section only can contain the address if
       // children contains an address. This allows for gaps between the children
       // that are contained in the address range for this section, but do not
       // produce
       // hits unless the children contain the address.
       m_encrypted : 1,         // Set to true if the contents are encrypted
       m_thread_specific : 1,   // This section is thread specific
       m_readable : 1,          // If this section has read permissions
       m_writable : 1,          // If this section has write permissions
-      m_executable : 1;        // If this section has executable permissions
+      m_executable : 1,        // If this section has executable permissions
+      m_relocated : 1;         // If this section has had relocations applied
   uint32_t m_target_byte_size; // Some architectures have non-8-bit byte size.
                                // This is specified as
                                // as a multiple number of a host bytes
 private:
   DISALLOW_COPY_AND_ASSIGN(Section);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Section_h_

include/lldb/Symbol/ArmUnwindInfo.h

  *     Date of Issue: 25th January 2007, reissued 30th November 2012
  *     http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038a/IHI0038A_ehabi.pdf
  */
 
 namespace lldb_private {
 
 class ArmUnwindInfo {
 public:
-  ArmUnwindInfo(const ObjectFile &objfile, lldb::SectionSP &arm_exidx,
+  ArmUnwindInfo(ObjectFile &objfile, lldb::SectionSP &arm_exidx,
                 lldb::SectionSP &arm_extab);
 
   ~ArmUnwindInfo();
 
   bool GetUnwindPlan(Target &target, const Address &addr,
                      UnwindPlan &unwind_plan);
 
 private:

include/lldb/Symbol/ObjectFile.h

public:
   /// until this accessor is called the first time.
   ///
   /// @return
   ///     The symbol table for this object file.
   //------------------------------------------------------------------
   virtual Symtab *GetSymtab() = 0;
 
   //------------------------------------------------------------------
+  /// Perform relocations on the section if necessary.
+  ///
+  //------------------------------------------------------------------
+  virtual void RelocateSectionIfNeeded(lldb_private::Section *section);
+
+  //------------------------------------------------------------------
   /// Appends a Symbol for the specified so_addr to the symbol table.
   ///
   /// If verify_unique is false, the symbol table is not searched
   /// to determine if a Symbol found at this address has already been
   /// added to the symbol table.  When verify_unique is true, this
   /// method resolves the Symbol as the first match in the SymbolTable
   /// and appends a Symbol only if required/found.
   ///
public:
   static lldb::DataBufferSP ReadMemory(const lldb::ProcessSP &process_sp,
                                        lldb::addr_t addr, size_t byte_size);
 
   size_t GetData(lldb::offset_t offset, size_t length,
                  DataExtractor &data) const;
 
   size_t CopyData(lldb::offset_t offset, size_t length, void *dst) const;
 
-  virtual size_t ReadSectionData(const Section *section,
+  virtual size_t ReadSectionData(Section *section,
                                  lldb::offset_t section_offset, void *dst,
-                                 size_t dst_len) const;
+                                 size_t dst_len);
 
-  virtual size_t ReadSectionData(const Section *section,
-                                 DataExtractor &section_data) const;
+  virtual size_t ReadSectionData(Section *section,
+                                 DataExtractor &section_data);
 
-  size_t MemoryMapSectionData(const Section *section,
-                              DataExtractor &section_data) const;
+  size_t MemoryMapSectionData(Section *section,
+                              DataExtractor &section_data);
 
   bool IsInMemory() const { return m_memory_addr != LLDB_INVALID_ADDRESS; }
 
   // Strip linker annotations (such as @@VERSION) from symbol names.
   virtual llvm::StringRef
   StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const {
     return symbol_name;
   }

source/Core/Section.cpp

Section::Section(const ModuleSP &module_sp, ObjectFile *obj_file,
                  uint32_t log2align, uint32_t flags,
                  uint32_t target_byte_size /*=1*/)
     : ModuleChild(module_sp), UserID(sect_id), Flags(flags),
       m_obj_file(obj_file), m_type(sect_type), m_parent_wp(), m_name(name),
       m_file_addr(file_addr), m_byte_size(byte_size),
       m_file_offset(file_offset), m_file_size(file_size),
       m_log2align(log2align), m_children(), m_fake(false), m_encrypted(false),
       m_thread_specific(false), m_readable(false), m_writable(false),
-      m_executable(false), m_target_byte_size(target_byte_size) {
+      m_executable(false), m_relocated(false), m_target_byte_size(target_byte_size) {
   //    printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16" PRIx64 ",
   //    addr=[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), file [0x%16.16" PRIx64 "
   //    - 0x%16.16" PRIx64 "), flags = 0x%8.8x, name = %s\n",
   //            this, module_sp.get(), sect_id, file_addr, file_addr +
   //            byte_size, file_offset, file_offset + file_size, flags,
   //            name.GetCString());
 }
 
 Section::Section(const lldb::SectionSP &parent_section_sp,
                  const ModuleSP &module_sp, ObjectFile *obj_file,
                  user_id_t sect_id, const ConstString &name,
                  SectionType sect_type, addr_t file_addr, addr_t byte_size,
                  lldb::offset_t file_offset, lldb::offset_t file_size,
                  uint32_t log2align, uint32_t flags,
                  uint32_t target_byte_size /*=1*/)
     : ModuleChild(module_sp), UserID(sect_id), Flags(flags),
       m_obj_file(obj_file), m_type(sect_type), m_parent_wp(), m_name(name),
       m_file_addr(file_addr), m_byte_size(byte_size),
       m_file_offset(file_offset), m_file_size(file_size),
       m_log2align(log2align), m_children(), m_fake(false), m_encrypted(false),
       m_thread_specific(false), m_readable(false), m_writable(false),
-      m_executable(false), m_target_byte_size(target_byte_size) {
+      m_executable(false), m_relocated(false), m_target_byte_size(target_byte_size) {
   //    printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16" PRIx64 ",
   //    addr=[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), file [0x%16.16" PRIx64 "
   //    - 0x%16.16" PRIx64 "), flags = 0x%8.8x, name = %s.%s\n",
   //            this, module_sp.get(), sect_id, file_addr, file_addr +
   //            byte_size, file_offset, file_offset + file_size, flags,
   //            parent_section_sp->GetName().GetCString(), name.GetCString());
   if (parent_section_sp)
     m_parent_wp = parent_section_sp;

 
 lldb::offset_t Section::GetSectionData(void *dst, lldb::offset_t dst_len,
                                        lldb::offset_t offset) {
   if (m_obj_file)
     return m_obj_file->ReadSectionData(this, offset, dst, dst_len);
   return 0;
 }
 
-lldb::offset_t Section::GetSectionData(DataExtractor &section_data) const {
+lldb::offset_t Section::GetSectionData(DataExtractor &section_data) {
   if (m_obj_file)
     return m_obj_file->ReadSectionData(this, section_data);
   return 0;
 }
 
 #pragma mark SectionList
 
 SectionList::SectionList() : m_sections() {}

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

private:
   lldb_private::Address m_entry_point_address;
 
   /// The architecture detected from parsing elf file contents.
   lldb_private::ArchSpec m_arch_spec;
 
   /// The address class for each symbol in the elf file
   FileAddressToAddressClassMap m_address_class_map;
 
   /// Returns a 1 based index of the given section header.
   size_t SectionIndex(const SectionHeaderCollIter &I);
 
   /// Returns a 1 based index of the given section header.
   size_t SectionIndex(const SectionHeaderCollConstIter &I) const;
 
   // Parses the ELF program headers.
   static size_t GetProgramHeaderInfo(ProgramHeaderColl &program_headers,
                                      lldb_private::DataExtractor &object_data,
private:
   unsigned ParseTrampolineSymbols(lldb_private::Symtab *symbol_table,
                                   lldb::user_id_t start_id,
                                   const ELFSectionHeaderInfo *rela_hdr,
                                   lldb::user_id_t section_id);
 
   void ParseUnwindSymbols(lldb_private::Symtab *symbol_table,
                           lldb_private::DWARFCallFrameInfo *eh_frame);
 
   /// Relocates debug sections
   unsigned RelocateDebugSections(const elf::ELFSectionHeader *rel_hdr,
-                                 lldb::user_id_t rel_id);
+                                 lldb::user_id_t rel_id,
+                                 lldb_private::Symtab *thetab);
+
+  void RelocateSectionIfNeeded(lldb_private::Section *section) override;
 
   unsigned RelocateSection(lldb_private::Symtab *symtab,
                            const elf::ELFHeader *hdr,
                            const elf::ELFSectionHeader *rel_hdr,
                            const elf::ELFSectionHeader *symtab_hdr,
                            const elf::ELFSectionHeader *debug_hdr,
                            lldb_private::DataExtractor &rel_data,
                            lldb_private::DataExtractor &symtab_data,

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp,
                                           DataBufferSP &data_sp,
                                           lldb::offset_t data_offset,
                                           const lldb_private::FileSpec *file,
                                           lldb::offset_t file_offset,
                                           lldb::offset_t length) {
   if (!data_sp) {
     data_sp =
-        DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
+        DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset, true);
     if (!data_sp)
       return nullptr;
     data_offset = 0;
   }
 
   assert(data_sp);
 
   if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
     return nullptr;
 
   const uint8_t *magic = data_sp->GetBytes() + data_offset;
   if (!ELFHeader::MagicBytesMatch(magic))
     return nullptr;
 
   // Update the data to contain the entire file if it doesn't already
   if (data_sp->GetByteSize() < length) {
     data_sp =
-        DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
+        DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset, true);
     if (!data_sp)
       return nullptr;
     data_offset = 0;
     magic = data_sp->GetBytes();
   }
 
   unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
   if (address_size == 4 || address_size == 8) {
lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) {
   if (!name || !name[0] || !ParseSectionHeaders())
     return 0;
   for (size_t i = 1; i < m_section_headers.size(); ++i)
     if (m_section_headers[i].section_name == ConstString(name))
       return i;
   return 0;
 }
 
 void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
   if (!m_sections_ap.get() && ParseSectionHeaders()) {
     m_sections_ap.reset(new SectionList());
 
+    // Object files frequently have 0 for every section address, meaning we
+    // need to compute synthetic addresses in order for "file addresses" from
+    // different sections to not overlap
+    bool synthaddrs = (CalculateType() == ObjectFile::Type::eTypeObjectFile);
+    uint64_t nextaddr = 0;
+
     for (SectionHeaderCollIter I = m_section_headers.begin();
          I != m_section_headers.end(); ++I) {
       const ELFSectionHeaderInfo &header = *I;
 
       ConstString &name = I->section_name;
       const uint64_t file_size =
           header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
       const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0;
 
       static ConstString g_sect_name_text(".text");
       static ConstString g_sect_name_data(".data");
       static ConstString g_sect_name_bss(".bss");
       static ConstString g_sect_name_tdata(".tdata");
       static ConstString g_sect_name_tbss(".tbss");
       static ConstString g_sect_name_dwarf_debug_abbrev(".debug_abbrev");
       static ConstString g_sect_name_dwarf_debug_addr(".debug_addr");
       static ConstString g_sect_name_dwarf_debug_aranges(".debug_aranges");
       static ConstString g_sect_name_dwarf_debug_cu_index(".debug_cu_index");
       static ConstString g_sect_name_dwarf_debug_frame(".debug_frame");
for (SectionHeaderCollIter I = m_section_headers.begin();
         sect_type = kalimbaSectionType(m_header, header);
       }
 
       const uint32_t target_bytes_size =
           (eSectionTypeData == sect_type || eSectionTypeZeroFill == sect_type)
               ? m_arch_spec.GetDataByteSize()
               : eSectionTypeCode == sect_type ? m_arch_spec.GetCodeByteSize()
                                               : 1;
-      const addr_t sect_file_addr = header.sh_flags & SHF_ALLOC
-                                                    ? header.sh_addr
-                                                    : LLDB_INVALID_ADDRESS;
       elf::elf_xword log2align =
           (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign);
+
+      uint64_t addr = header.sh_addr;
+
+      if ((header.sh_flags & SHF_ALLOC) && synthaddrs) {
+          nextaddr =
+              (nextaddr + header.sh_addralign - 1) & ~(header.sh_addralign - 1);
+          addr = nextaddr;
+          nextaddr += vm_size;
+      }
+
       SectionSP section_sp(new Section(
           GetModule(), // Module to which this section belongs.
           this, // ObjectFile to which this section belongs and should read
                 // section data from.
           SectionIndex(I),     // Section ID.
           name,                // Section name.
           sect_type,           // Section type.
-          sect_file_addr,      // VM address.
+          addr,                // VM address.
           vm_size,             // VM size in bytes of this section.
           header.sh_offset,    // Offset of this section in the file.
           file_size,           // Size of the section as found in the file.
           log2align,           // Alignment of the section
           header.sh_flags,     // Flags for this section.
           target_bytes_size)); // Number of host bytes per target byte
 
       section_sp->SetPermissions(permissions);
if (hdr->Is32Bit()) {
       }
     }
   }
 
   return 0;
 }
 
 unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr,
-                                              user_id_t rel_id) {
+                                              user_id_t rel_id,
+                                              lldb_private::Symtab *thetab) {
   assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL);
 
   // Parse in the section list if needed.
   SectionList *section_list = GetSectionList();
   if (!section_list)
     return 0;
 
   // Section ID's are ones based.
unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr,
   Section *debug = section_list->FindSectionByID(debug_id).get();
   if (!debug)
     return 0;
 
   DataExtractor rel_data;
   DataExtractor symtab_data;
   DataExtractor debug_data;
 
-  if (ReadSectionData(rel, rel_data) && ReadSectionData(symtab, symtab_data) &&
-      ReadSectionData(debug, debug_data)) {
-    RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr,
+  if (GetData(rel->GetFileOffset(), rel->GetFileSize(), rel_data) &&
+      GetData(symtab->GetFileOffset(), symtab->GetFileSize(), symtab_data) &&
+      GetData(debug->GetFileOffset(), debug->GetFileSize(), debug_data)) {
+    RelocateSection(thetab, &m_header, rel_hdr, symtab_hdr,
                     debug_hdr, rel_data, symtab_data, debug_data, debug);
   }
 
   return 0;
 }
 
 Symtab *ObjectFileELF::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (!module_sp)
     return NULL;
 
   // We always want to use the main object file so we (hopefully) only have one
   // cached copy
   // of our symtab, dynamic sections, etc.
   ObjectFile *module_obj_file = module_sp->GetObjectFile();
   if (module_obj_file && module_obj_file != this)
     return module_obj_file->GetSymtab();
 
   if (m_symtab_ap.get() == NULL) {
     SectionList *section_list = module_sp->GetSectionList();
     if (!section_list)
       return NULL;
 
     uint64_t symbol_id = 0;
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
     // Sharable objects and dynamic executables usually have 2 distinct symbol
     // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
     // smaller
if (m_symtab_ap.get() == NULL) {
     // do the section
     // lookup next time.
     if (m_symtab_ap == nullptr)
       m_symtab_ap.reset(new Symtab(this));
 
     m_symtab_ap->CalculateSymbolSizes();
   }
 
+  return m_symtab_ap.get();
+}
+
+void ObjectFileELF::RelocateSectionIfNeeded(lldb_private::Section *section)
+{
+  static const char *debug_prefix = ".debug";
+
+  // Set relocated bit so we stop getting called, regardless of
+  // whether we actually relocate.
+  section->SetIsRelocated(true);
+
+  // We only relocate in ELF relocatable files
+  if (CalculateType() != eTypeObjectFile)
+    return;
+
+  const char *section_name = section->GetName().GetCString();
+  // Can't relocate that which can't be named
+  if (section_name == nullptr)
+    return;
+
+  // We don't relocate non-debug sections at the moment
+  if (strncmp(section_name, debug_prefix, strlen(debug_prefix)))
+    return;
+
+  // Relocation section names to look for
+  std::string needle = std::string(".rel") + section_name;
+  std::string needlea = std::string(".rela") + section_name;
+
   for (SectionHeaderCollIter I = m_section_headers.begin();
        I != m_section_headers.end(); ++I) {
     if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) {
-      if (CalculateType() == eTypeObjectFile) {
-        const char *section_name = I->section_name.AsCString("");
-        if (strstr(section_name, ".rela.debug") ||
-            strstr(section_name, ".rel.debug")) {
-          const ELFSectionHeader &reloc_header = *I;
-          user_id_t reloc_id = SectionIndex(I);
-          RelocateDebugSections(&reloc_header, reloc_id);
-        }
+      const char *hay_name = I->section_name.GetCString();
+      if (hay_name == nullptr)
+        continue;
+      if (needle == hay_name || needlea == hay_name) {
+        RelocateDebugSections(&reloc_header, reloc_id, GetSymtab());
+        break;
       }
     }
   }
-  return m_symtab_ap.get();
 }
 
 void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table,
                                        DWARFCallFrameInfo *eh_frame) {
   SectionList *section_list = GetSectionList();
   if (!section_list)
     return;
 

source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

public:
   void Dump(lldb_private::Stream *s) override;
 
   bool GetArchitecture(lldb_private::ArchSpec &arch) override;
 
   bool GetUUID(lldb_private::UUID *uuid) override;
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 
-  size_t ReadSectionData(const lldb_private::Section *section,
+  size_t ReadSectionData(lldb_private::Section *section,
                          lldb::offset_t section_offset, void *dst,
-                         size_t dst_len) const override;
+                         size_t dst_len) override;
 
   size_t
-  ReadSectionData(const lldb_private::Section *section,
-                  lldb_private::DataExtractor &section_data) const override;
+  ReadSectionData(lldb_private::Section *section,
+                  lldb_private::DataExtractor &section_data) override;
 
   lldb_private::Address GetEntryPointAddress() override;
 
   lldb_private::Address GetHeaderAddress() override;
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;

source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
                 section_sp, section_sp->GetFileAddress() + value))
           ++num_loaded_sections;
       }
     }
   }
   return num_loaded_sections > 0;
 }
 
-size_t ObjectFileJIT::ReadSectionData(const lldb_private::Section *section,
+size_t ObjectFileJIT::ReadSectionData(lldb_private::Section *section,
                                       lldb::offset_t section_offset, void *dst,
-                                      size_t dst_len) const {
+                                      size_t dst_len) {
   lldb::offset_t file_size = section->GetFileSize();
   if (section_offset < file_size) {
     size_t src_len = file_size - section_offset;
     if (src_len > dst_len)
       src_len = dst_len;
     const uint8_t *src =
         ((uint8_t *)(uintptr_t)section->GetFileOffset()) + section_offset;
 
     memcpy(dst, src, src_len);
     return src_len;
   }
   return 0;
 }
 
 size_t ObjectFileJIT::ReadSectionData(
-    const lldb_private::Section *section,
-    lldb_private::DataExtractor &section_data) const {
+    lldb_private::Section *section,
+    lldb_private::DataExtractor &section_data) {
   if (section->GetFileSize()) {
     const void *src = (void *)(uintptr_t)section->GetFileOffset();
 
     DataBufferSP data_sp(
         new lldb_private::DataBufferHeap(src, section->GetFileSize()));
     if (data_sp) {
       section_data.SetData(data_sp, 0, data_sp->GetByteSize());
       section_data.SetByteOrder(GetByteOrder());
       section_data.SetAddressByteSize(GetAddressByteSize());
       return section_data.GetByteSize();
     }
   }
   section_data.Clear();
   return 0;
 }

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

TypeSystem *SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
   }
   return type_system;
 }
 
 void SymbolFileDWARF::InitializeObject() {
   ModuleSP module_sp(m_obj_file->GetModule());
   if (module_sp) {
     const SectionList *section_list = module_sp->GetSectionList();
-    const Section *section =
+    Section *section =
         section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();
 
     // Memory map the DWARF mach-o segment so we have everything mmap'ed
     // to keep our heap memory usage down.
     if (section)
       m_obj_file->MemoryMapSectionData(section, m_dwarf_data);
   }
 
return GetCachedSectionData(eSectionTypeDWARFDebugAranges,
                               m_data_debug_aranges);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_frame_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugFrame, m_data_debug_frame);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_info_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugInfo, m_data_debug_info);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_line_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugLine, m_data_debug_line);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_macro_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugMacro, m_data_debug_macro);
 }

source/Symbol/ArmUnwindInfo.cpp

 ArmUnwindInfo::ArmExidxEntry::ArmExidxEntry(uint32_t f, lldb::addr_t a,
                                             uint32_t d)
     : file_address(f), address(a), data(d) {}
 
 bool ArmUnwindInfo::ArmExidxEntry::operator<(const ArmExidxEntry &other) const {
   return address < other.address;
 }
 
-ArmUnwindInfo::ArmUnwindInfo(const ObjectFile &objfile, SectionSP &arm_exidx,
+ArmUnwindInfo::ArmUnwindInfo(ObjectFile &objfile, SectionSP &arm_exidx,
                              SectionSP &arm_extab)
     : m_byte_order(objfile.GetByteOrder()), m_arm_exidx_sp(arm_exidx),
       m_arm_extab_sp(arm_extab) {
   objfile.ReadSectionData(arm_exidx.get(), m_arm_exidx_data);
   objfile.ReadSectionData(arm_extab.get(), m_arm_extab_data);
 
   addr_t exidx_base_addr = m_arm_exidx_sp->GetFileAddress();
 

source/Symbol/ObjectFile.cpp

 size_t ObjectFile::CopyData(lldb::offset_t offset, size_t length,
                             void *dst) const {
   // The entire file has already been mmap'ed into m_data, so just copy from
   // there
   // Note that the data remains in target byte order.
   return m_data.CopyData(offset, length, dst);
 }
 
-size_t ObjectFile::ReadSectionData(const Section *section,
+size_t ObjectFile::ReadSectionData(Section *section,
                                    lldb::offset_t section_offset, void *dst,
-                                   size_t dst_len) const {
+                                   size_t dst_len) {
   assert(section);
   section_offset *= section->GetTargetByteSize();
 
   // If some other objectfile owns this data, pass this to them.
   if (section->GetObjectFile() != this)
     return section->GetObjectFile()->ReadSectionData(section, section_offset,
                                                      dst, dst_len);
 
   if (IsInMemory()) {
     ProcessSP process_sp(m_process_wp.lock());
     if (process_sp) {
       Status error;
       const addr_t base_load_addr =
           section->GetLoadBaseAddress(&process_sp->GetTarget());
       if (base_load_addr != LLDB_INVALID_ADDRESS)
         return process_sp->ReadMemory(base_load_addr + section_offset, dst,
                                       dst_len, error);
     }
   } else {
+    if (!section->IsRelocated())
+      RelocateSectionIfNeeded(section);
+
     const lldb::offset_t section_file_size = section->GetFileSize();
     if (section_offset < section_file_size) {
       const size_t section_bytes_left = section_file_size - section_offset;
       size_t section_dst_len = dst_len;
       if (section_dst_len > section_bytes_left)
         section_dst_len = section_bytes_left;
       return CopyData(section->GetFileOffset() + section_offset,
                       section_dst_len, dst);
if (IsInMemory()) {
     }
   }
   return 0;
 }
 
 //----------------------------------------------------------------------
 // Get the section data the file on disk
 //----------------------------------------------------------------------
-size_t ObjectFile::ReadSectionData(const Section *section,
-                                   DataExtractor &section_data) const {
+size_t ObjectFile::ReadSectionData(Section *section,
+                                   DataExtractor &section_data) {
   // If some other objectfile owns this data, pass this to them.
   if (section->GetObjectFile() != this)
     return section->GetObjectFile()->ReadSectionData(section, section_data);
 
   if (IsInMemory()) {
     ProcessSP process_sp(m_process_wp.lock());
     if (process_sp) {
       const addr_t base_load_addr =
return GetData(section->GetFileOffset(), section->GetFileSize(),
                    section_data);
   } else {
     // The object file now contains a full mmap'ed copy of the object file data,
     // so just use this
     return MemoryMapSectionData(section, section_data);
   }
 }
 
-size_t ObjectFile::MemoryMapSectionData(const Section *section,
-                                        DataExtractor &section_data) const {
+size_t ObjectFile::MemoryMapSectionData(Section *section,
+                                        DataExtractor &section_data) {
   // If some other objectfile owns this data, pass this to them.
   if (section->GetObjectFile() != this)
     return section->GetObjectFile()->MemoryMapSectionData(section,
                                                           section_data);
 
   if (IsInMemory()) {
     return ReadSectionData(section, section_data);
   } else {
+    if (!section->IsRelocated())
+      RelocateSectionIfNeeded(section);
+
     // The object file now contains a full mmap'ed copy of the object file data,
     // so just use this
     return GetData(section->GetFileOffset(), section->GetFileSize(),
                    section_data);
   }
 }
 
 bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object,
if (set_pc) {
     ThreadList &thread_list = process->GetThreadList();
     ThreadSP curr_thread(thread_list.GetSelectedThread());
     RegisterContextSP reg_context(curr_thread->GetRegisterContext());
     Address file_entry = GetEntryPointAddress();
     reg_context->SetPC(file_entry.GetLoadAddress(&target));
   }
   return error;
 }
+
+void ObjectFile::RelocateSectionIfNeeded(lldb_private::Section *section)
+{
+}