Rename ObjectFile::GetHeaderAddress to GetBaseAddress

[labath]

Summary

This function was named such because in the case of MachO files, the
mach header is located at this address. However all (most?) usages of
this function were not interested in that fact, but the fact that this
address is used as the base address for expressing various relative
addresses in the object file.

For other object file formats, this name is not appropriate (and it's
probably the reason why this function was not implemented in these
classes). In the ELF case the ELF header will usually end up at this
address, but this is a result of the linker optimizing the file layout
and not a requirement of the spec. For COFF files, I believe the is no
header located at this address either.

[labath]

Adding a bunch of people to make sure this makes sense for all object formats (I am particularly oblivious to how COFF works). If this makes sense, I'll implement this function in ObjectFilePECOFF and ELF to return the "image base" and "base address" respectively.

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

1676–1677 ↗

(On Diff #177165)

This is the most dodgy usage I believe. It looks like this piece of code is expecting to use the base ObjectFile implementation of this function, which returns the m_memory_addr member. However, this will in reality call the MachO implementation which does something completely different (and independent of being in memory). It might be better to change this to GetObjectFile()->IsInMemory(), but I have no idea how to verify that.

[clayborg]

Looks fine. Just one clarification in the header documentation and this is good to go.

include/lldb/Symbol/ObjectFile.h

561 ↗

(On Diff #177165)

/// offset member filled in indicating the resulting Address object represents a file address.

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

1677 ↗

(On Diff #177165)

Switching to IsInMemory will work. This code probably predates the existence of IsInMemory().

[labath]

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

1677 ↗

(On Diff #177165)

Ok, I'll check this in separately, as this is the only functional change in this commit.

lldb/trunk/include/lldb/Symbol/ObjectFile.h

public:
   /// file) then an invalid address is returned.
   ///
   /// @return
   ///     Returns the entry address for this module.
   //------------------------------------------------------------------
   virtual lldb_private::Address GetEntryPointAddress() { return Address(); }
 
   //------------------------------------------------------------------
-  /// Returns the address that represents the header of this object file.
+  /// Returns base address of this object file.
   ///
-  /// The header address is defined as where the header for the object file is
-  /// that describes the content of the file. If the header doesn't appear in
-  /// a section that is defined in the object file, an address with no section
-  /// is returned that has the file offset set in the m_file_offset member of
-  /// the lldb_private::Address object.
-  ///
-  /// @return
-  ///     Returns the entry address for this module.
+  /// This also sometimes referred to as the "preferred load address" or the
+  /// "image base address". Addresses within object files are often expressed
+  /// relative to this base. If this address corresponds to a specific section
+  /// (usually the first byte of the first section) then the returned address
+  /// will have this section set. Otherwise, the address will just have the
+  /// offset member filled in, indicating that this represents a file address.
   //------------------------------------------------------------------
-  virtual lldb_private::Address GetHeaderAddress() {
+  virtual lldb_private::Address GetBaseAddress() {
     return Address(m_memory_addr);
   }
 
   virtual uint32_t GetNumThreadContexts() { return 0; }
 
   //------------------------------------------------------------------
   /// Some object files may have an identifier string embedded in them, e.g.
   /// in a Mach-O core file using the LC_IDENT load command (which  is

lldb/trunk/source/API/SBModule.cpp

 }
 
 lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
   lldb::SBAddress sb_addr;
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     ObjectFile *objfile_ptr = module_sp->GetObjectFile();
     if (objfile_ptr)
-      sb_addr.ref() = objfile_ptr->GetHeaderAddress();
+      sb_addr.ref() = objfile_ptr->GetBaseAddress();
   }
   return sb_addr;
 }
 
 lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
   lldb::SBAddress sb_addr;
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     ObjectFile *objfile_ptr = module_sp->GetObjectFile();
     if (objfile_ptr)
       sb_addr.ref() = objfile_ptr->GetEntryPointAddress();
   }
   return sb_addr;
 }

lldb/trunk/source/Commands/CommandObjectTarget.cpp

 // List images with associated information
 //----------------------------------------------------------------------
 
 static constexpr OptionDefinition g_target_modules_list_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "address",        'a', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeAddressOrExpression, "Display the image at this address." },
   { LLDB_OPT_SET_1, false, "arch",           'A', OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeWidth,               "Display the architecture when listing images." },
   { LLDB_OPT_SET_1, false, "triple",         't', OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeWidth,               "Display the triple when listing images." },
-  { LLDB_OPT_SET_1, false, "header",         'h', OptionParser::eNoArgument,       nullptr, {}, 0, eArgTypeNone,                "Display the image header address as a load address if debugging, a file address otherwise." },
-  { LLDB_OPT_SET_1, false, "offset",         'o', OptionParser::eNoArgument,       nullptr, {}, 0, eArgTypeNone,                "Display the image header address offset from the header file address (the slide amount)." },
+  { LLDB_OPT_SET_1, false, "header",         'h', OptionParser::eNoArgument,       nullptr, {}, 0, eArgTypeNone,                "Display the image base address as a load address if debugging, a file address otherwise." },
+  { LLDB_OPT_SET_1, false, "offset",         'o', OptionParser::eNoArgument,       nullptr, {}, 0, eArgTypeNone,                "Display the image load address offset from the base file address (the slide amount)." },
   { LLDB_OPT_SET_1, false, "uuid",           'u', OptionParser::eNoArgument,       nullptr, {}, 0, eArgTypeNone,                "Display the UUID when listing images." },
   { LLDB_OPT_SET_1, false, "fullpath",       'f', OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeWidth,               "Display the fullpath to the image object file." },
   { LLDB_OPT_SET_1, false, "directory",      'd', OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeWidth,               "Display the directory with optional width for the image object file." },
   { LLDB_OPT_SET_1, false, "basename",       'b', OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeWidth,               "Display the basename with optional width for the image object file." },
   { LLDB_OPT_SET_1, false, "symfile",        's', OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeWidth,               "Display the fullpath to the image symbol file with optional width." },
   { LLDB_OPT_SET_1, false, "symfile-unique", 'S', OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeWidth,               "Display the symbol file with optional width only if it is different from the executable object file." },
   { LLDB_OPT_SET_1, false, "mod-time",       'm', OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeWidth,               "Display the modification time with optional width of the module." },
   { LLDB_OPT_SET_1, false, "ref-count",      'r', OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeWidth,               "Display the reference count if the module is still in the shared module cache." },
for (size_t i = 0; i < num_entries; ++i) {
         // Image header address
         {
           uint32_t addr_nibble_width =
               target ? (target->GetArchitecture().GetAddressByteSize() * 2)
                      : 16;
 
           ObjectFile *objfile = module->GetObjectFile();
           if (objfile) {
-            Address header_addr(objfile->GetHeaderAddress());
-            if (header_addr.IsValid()) {
+            Address base_addr(objfile->GetBaseAddress());
+            if (base_addr.IsValid()) {
               if (target && !target->GetSectionLoadList().IsEmpty()) {
-                lldb::addr_t header_load_addr =
-                    header_addr.GetLoadAddress(target);
-                if (header_load_addr == LLDB_INVALID_ADDRESS) {
-                  header_addr.Dump(&strm, target,
+                lldb::addr_t load_addr =
+                    base_addr.GetLoadAddress(target);
+                if (load_addr == LLDB_INVALID_ADDRESS) {
+                  base_addr.Dump(&strm, target,
                                    Address::DumpStyleModuleWithFileAddress,
                                    Address::DumpStyleFileAddress);
                 } else {
                   if (format_char == 'o') {
                     // Show the offset of slide for the image
                     strm.Printf(
                         "0x%*.*" PRIx64, addr_nibble_width, addr_nibble_width,
-                        header_load_addr - header_addr.GetFileAddress());
+                        load_addr - base_addr.GetFileAddress());
                   } else {
                     // Show the load address of the image
                     strm.Printf("0x%*.*" PRIx64, addr_nibble_width,
-                                addr_nibble_width, header_load_addr);
+                                addr_nibble_width, load_addr);
                   }
                 }
                 break;
               }
               // The address was valid, but the image isn't loaded, output the
               // address in an appropriate format
-              header_addr.Dump(&strm, target, Address::DumpStyleFileAddress);
+              base_addr.Dump(&strm, target, Address::DumpStyleFileAddress);
               break;
             }
           }
           strm.Printf("%*s", addr_nibble_width + 2, "");
         }
         break;
 
       case 'r': {

lldb/trunk/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

DynamicLoaderDarwinKernel::SearchForKernelAtSameLoadAddr(Process *process) {
   ObjectFile *exe_objfile = exe_module->GetObjectFile();
   if (exe_objfile == NULL)
     return LLDB_INVALID_ADDRESS;
 
   if (exe_objfile->GetType() != ObjectFile::eTypeExecutable ||
       exe_objfile->GetStrata() != ObjectFile::eStrataKernel)
     return LLDB_INVALID_ADDRESS;
 
-  if (!exe_objfile->GetHeaderAddress().IsValid())
+  if (!exe_objfile->GetBaseAddress().IsValid())
     return LLDB_INVALID_ADDRESS;
 
   if (CheckForKernelImageAtAddress(
-          exe_objfile->GetHeaderAddress().GetFileAddress(), process) ==
+          exe_objfile->GetBaseAddress().GetFileAddress(), process) ==
       exe_module->GetUUID())
-    return exe_objfile->GetHeaderAddress().GetFileAddress();
+    return exe_objfile->GetBaseAddress().GetFileAddress();
 
   return LLDB_INVALID_ADDRESS;
 }
 
 //----------------------------------------------------------------------
 // If the debug flag is included in the boot-args nvram setting, the kernel's
 // load address will be noted in the lowglo page at a fixed address Returns the
 // address of the kernel if one was found, else LLDB_INVALID_ADDRESS.
bool DynamicLoaderDarwinKernel::KextImageInfo::LoadImageUsingMemoryModule(
   bool is_loaded = IsLoaded();
 
   if (is_loaded && m_module_sp && IsKernel()) {
     Stream *s = target.GetDebugger().GetOutputFile().get();
     if (s) {
       ObjectFile *kernel_object_file = m_module_sp->GetObjectFile();
       if (kernel_object_file) {
         addr_t file_address =
-            kernel_object_file->GetHeaderAddress().GetFileAddress();
+            kernel_object_file->GetBaseAddress().GetFileAddress();
         if (m_load_address != LLDB_INVALID_ADDRESS &&
             file_address != LLDB_INVALID_ADDRESS) {
           s->Printf("Kernel slid 0x%" PRIx64 " in memory.\n",
                     m_load_address - file_address);
         }
       }
       {
         s->Printf("Loaded kernel file %s\n",
if (m_kernel.GetLoadAddress() == LLDB_INVALID_ADDRESS) {
       m_kernel.SetLoadAddress(m_kernel_load_address);
       if (m_kernel.GetLoadAddress() == LLDB_INVALID_ADDRESS &&
           m_kernel.GetModule()) {
         // We didn't get a hint from the process, so we will try the kernel at
         // the address that it exists at in the file if we have one
         ObjectFile *kernel_object_file = m_kernel.GetModule()->GetObjectFile();
         if (kernel_object_file) {
           addr_t load_address =
-              kernel_object_file->GetHeaderAddress().GetLoadAddress(
+              kernel_object_file->GetBaseAddress().GetLoadAddress(
                   &m_process->GetTarget());
           addr_t file_address =
-              kernel_object_file->GetHeaderAddress().GetFileAddress();
+              kernel_object_file->GetBaseAddress().GetFileAddress();
           if (load_address != LLDB_INVALID_ADDRESS && load_address != 0) {
             m_kernel.SetLoadAddress(load_address);
             if (load_address != file_address) {
               // Don't accidentally relocate the kernel to the File address --
               // the Load address has already been set to its actual in-memory
               // address. Mark it as IsLoaded.
               m_kernel.SetProcessStopId(m_process->GetStopID());
             }

lldb/trunk/source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

size_t ReadSectionData(lldb_private::Section *section,
                          size_t dst_len) override;
 
   size_t
   ReadSectionData(lldb_private::Section *section,
                   lldb_private::DataExtractor &section_data) override;
 
   lldb_private::Address GetEntryPointAddress() override;
 
-  lldb_private::Address GetHeaderAddress() override;
+  lldb_private::Address GetBaseAddress() override;
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;
 
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------

lldb/trunk/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

uint32_t ObjectFileJIT::GetDependentModules(FileSpecList &files) {
   files.Clear();
   return 0;
 }
 
 lldb_private::Address ObjectFileJIT::GetEntryPointAddress() {
   return Address();
 }
 
-lldb_private::Address ObjectFileJIT::GetHeaderAddress() { return Address(); }
+lldb_private::Address ObjectFileJIT::GetBaseAddress() { return Address(); }
 
 ObjectFile::Type ObjectFileJIT::CalculateType() { return eTypeJIT; }
 
 ObjectFile::Strata ObjectFileJIT::CalculateStrata() { return eStrataJIT; }
 
 bool ObjectFileJIT::GetArchitecture(ArchSpec &arch) {
   ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock());
   if (delegate_sp)

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

public:
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 
   lldb_private::FileSpecList GetReExportedLibraries() override {
     return m_reexported_dylibs;
   }
 
   lldb_private::Address GetEntryPointAddress() override;
 
-  lldb_private::Address GetHeaderAddress() override;
+  lldb_private::Address GetBaseAddress() override;
 
   uint32_t GetNumThreadContexts() override;
 
   std::string GetIdentifierString() override;
 
   bool GetCorefileMainBinaryInfo (lldb::addr_t &address, lldb_private::UUID &uuid) override;
 
   lldb::RegisterContextSP

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (add_section && (const_segname || is_core)) {
     segment_sp->SetIsEncrypted(segment_is_encrypted);
     m_sections_ap->AddSection(segment_sp);
     segment_sp->SetPermissions(segment_permissions);
     if (add_to_unified)
       context.UnifiedList.AddSection(segment_sp);
   } else if (unified_section_sp) {
     if (is_dsym && unified_section_sp->GetFileAddress() != load_cmd.vmaddr) {
       // Check to see if the module was read from memory?
-      if (module_sp->GetObjectFile()->GetHeaderAddress().IsValid()) {
+      if (module_sp->GetObjectFile()->GetBaseAddress().IsValid()) {
         // We have a module that is in memory and needs to have its file
         // address adjusted. We need to do this because when we load a file
         // from memory, its addresses will be slid already, yet the addresses
         // in the new symbol file will still be unslid.  Since everything is
         // stored as section offset, this shouldn't cause any problems.
 
         // Make sure we've parsed the symbol table from the ObjectFile before
         // we go around changing its Sections.
if (start_address != LLDB_INVALID_ADDRESS) {
         }
       }
     }
   }
 
   return m_entry_point_address;
 }
 
-lldb_private::Address ObjectFileMachO::GetHeaderAddress() {
+lldb_private::Address ObjectFileMachO::GetBaseAddress() {
   lldb_private::Address header_addr;
   SectionList *section_list = GetSectionList();
   if (section_list) {
     SectionSP text_segment_sp(
         section_list->FindSectionByName(GetSegmentNameTEXT()));
     if (text_segment_sp) {
       header_addr.SetSection(text_segment_sp);
       header_addr.SetOffset(0);

lldb/trunk/source/Symbol/CompactUnwindInfo.cpp

if (m_objfile.GetArchitecture(arch)) {
       }
 
       if (function_info.valid_range_offset_start != 0 &&
           function_info.valid_range_offset_end != 0) {
         SectionList *sl = m_objfile.GetSectionList();
         if (sl) {
           addr_t func_range_start_file_addr =
               function_info.valid_range_offset_start +
-              m_objfile.GetHeaderAddress().GetFileAddress();
+              m_objfile.GetBaseAddress().GetFileAddress();
           AddressRange func_range(func_range_start_file_addr,
                                   function_info.valid_range_offset_end -
                                       function_info.valid_range_offset_start,
                                   sl);
           unwind_plan.SetPlanValidAddressRange(func_range);
         }
       }
 
if (sl) {
     if (text_sect.get()) {
       text_section_file_address = text_sect->GetFileAddress();
     }
   }
   if (text_section_file_address == LLDB_INVALID_ADDRESS)
     return false;
 
   addr_t function_offset =
-      address.GetFileAddress() - m_objfile.GetHeaderAddress().GetFileAddress();
+      address.GetFileAddress() - m_objfile.GetBaseAddress().GetFileAddress();
 
   UnwindIndex key;
   key.function_offset = function_offset;
 
   std::vector<UnwindIndex>::const_iterator it;
   it = std::lower_bound(m_indexes.begin(), m_indexes.end(), key);
   if (it == m_indexes.end()) {
     return false;
if (kind == UNWIND_SECOND_LEVEL_REGULAR) {
     }
     entry_offset += 4; // skip over functionOffset
     unwind_info.encoding = m_unwindinfo_data.GetU32(&entry_offset); // encoding
     if (unwind_info.encoding & UNWIND_HAS_LSDA) {
       SectionList *sl = m_objfile.GetSectionList();
       if (sl) {
         uint32_t lsda_offset = GetLSDAForFunctionOffset(
             lsda_array_start, lsda_array_count, function_offset);
-        addr_t objfile_header_file_address =
-            m_objfile.GetHeaderAddress().GetFileAddress();
+        addr_t objfile_base_address =
+            m_objfile.GetBaseAddress().GetFileAddress();
         unwind_info.lsda_address.ResolveAddressUsingFileSections(
-            objfile_header_file_address + lsda_offset, sl);
+            objfile_base_address + lsda_offset, sl);
       }
     }
     if (unwind_info.encoding & UNWIND_PERSONALITY_MASK) {
       uint32_t personality_index =
           EXTRACT_BITS(unwind_info.encoding, UNWIND_PERSONALITY_MASK);
 
       if (personality_index > 0) {
         personality_index--;
         if (personality_index < m_unwind_header.personality_array_count) {
           offset_t offset = m_unwind_header.personality_array_offset;
           offset += 4 * personality_index;
           SectionList *sl = m_objfile.GetSectionList();
           if (sl) {
             uint32_t personality_offset = m_unwindinfo_data.GetU32(&offset);
-            addr_t objfile_header_file_address =
-                m_objfile.GetHeaderAddress().GetFileAddress();
+            addr_t objfile_base_address =
+                m_objfile.GetBaseAddress().GetFileAddress();
             unwind_info.personality_ptr_address.ResolveAddressUsingFileSections(
-                objfile_header_file_address + personality_offset, sl);
+                objfile_base_address + personality_offset, sl);
           }
         }
       }
     }
     return true;
   } else if (kind == UNWIND_SECOND_LEVEL_COMPRESSED) {
     // struct unwind_info_compressed_second_level_page_header {
     //     uint32_t    kind;    // UNWIND_SECOND_LEVEL_COMPRESSED
if (encoding == 0)
       return false;
 
     unwind_info.encoding = encoding;
     if (unwind_info.encoding & UNWIND_HAS_LSDA) {
       SectionList *sl = m_objfile.GetSectionList();
       if (sl) {
         uint32_t lsda_offset = GetLSDAForFunctionOffset(
             lsda_array_start, lsda_array_count, function_offset);
-        addr_t objfile_header_file_address =
-            m_objfile.GetHeaderAddress().GetFileAddress();
+        addr_t objfile_base_address =
+            m_objfile.GetBaseAddress().GetFileAddress();
         unwind_info.lsda_address.ResolveAddressUsingFileSections(
-            objfile_header_file_address + lsda_offset, sl);
+            objfile_base_address + lsda_offset, sl);
       }
     }
     if (unwind_info.encoding & UNWIND_PERSONALITY_MASK) {
       uint32_t personality_index =
           EXTRACT_BITS(unwind_info.encoding, UNWIND_PERSONALITY_MASK);
 
       if (personality_index > 0) {
         personality_index--;
         if (personality_index < m_unwind_header.personality_array_count) {
           offset_t offset = m_unwind_header.personality_array_offset;
           offset += 4 * personality_index;
           SectionList *sl = m_objfile.GetSectionList();
           if (sl) {
             uint32_t personality_offset = m_unwindinfo_data.GetU32(&offset);
-            addr_t objfile_header_file_address =
-                m_objfile.GetHeaderAddress().GetFileAddress();
+            addr_t objfile_base_address =
+                m_objfile.GetBaseAddress().GetFileAddress();
             unwind_info.personality_ptr_address.ResolveAddressUsingFileSections(
-                objfile_header_file_address + personality_offset, sl);
+                objfile_base_address + personality_offset, sl);
           }
         }
       }
     }
     return true;
   }
   return false;
 }