Tidy ELF section rewriting internal interface.

tools/relocation_packer/src/elf_file.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Implementation notes:
 //
 // We need to remove a piece from the ELF shared library.  However, we also
 // want to ensure that code and data loads at the same addresses as before
 // packing, so that tools like breakpad can still match up addresses found
 // in any crash dumps with data extracted from the pre-packed version of
@@ skipping 53 matching lines @@
 // by ensuring that a call to elf_getdata(section, data) returns NULL as
 // the next data entry.
 Elf_Data* GetSectionData(Elf_Scn* section) {
   Elf_Data* data = elf_getdata(section, NULL);
   CHECK(data && elf_getdata(section, data) == NULL);
   return data;
 }
 
 // Rewrite section data.  Allocates new data and makes it the data element's
 // buffer.  Relies on program exit to free allocated data.
-void RewriteSectionData(Elf_Data* data,
+void RewriteSectionData(Elf_Scn* section,
                         const void* section_data,
                         size_t size) {
+  Elf_Data* data = GetSectionData(section);
   CHECK(size == data->d_size);
   uint8_t* area = new uint8_t[size];
   memcpy(area, section_data, size);
   data->d_buf = area;
 }
 
 // Verbose ELF header logging.
 void VerboseLogElfHeader(const ELF::Ehdr* elf_header) {
   VLOG(1) << "e_phoff = " << elf_header->e_phoff;
   VLOG(1) << "e_shoff = " << elf_header->e_shoff;
@@ skipping 703 matching lines @@
 
     // DT_RELENT and DT_RELAENT do not change, but make sure they are what
     // we expect.  Only one will be present.
     if (tag == DT_RELENT || tag == DT_RELAENT) {
       CHECK(dynamic->d_un.d_val == sizeof(Rel));
     }
   }
 
   void* section_data = &dynamics[0];
   size_t bytes = dynamics.size() * sizeof(dynamics[0]);
-  RewriteSectionData(data, section_data, bytes);
+  RewriteSectionData(dynamic_section, section_data, bytes);
 }
 
 // Resize a section.  If the new size is larger than the current size, open
 // up a hole by increasing file offsets that come after the hole.  If smaller
 // than the current size, remove the hole by decreasing those offsets.
 template <typename Rel>
 void ResizeSection(Elf* elf, Elf_Scn* section, size_t new_size) {
   ELF::Shdr* section_header = ELF::getshdr(section);
   if (section_header->sh_size == new_size)
     return;
@@ skipping 134 matching lines @@
   Elf_Data* data = GetSectionData(relocations_section_);
 
   if (relocations_type_ == REL) {
     // Convert data to a vector of relocations.
     const ELF::Rel* relocations_base = reinterpret_cast<ELF::Rel*>(data->d_buf);
     std::vector<ELF::Rel> relocations(
         relocations_base,
         relocations_base + data->d_size / sizeof(relocations[0]));
 
     LOG(INFO) << "Relocations   : REL";
-    return PackTypedRelocations<ELF::Rel>(relocations, data);
+    return PackTypedRelocations<ELF::Rel>(relocations);
   }
 
   if (relocations_type_ == RELA) {
     // Convert data to a vector of relocations with addends.
     const ELF::Rela* relocations_base =
         reinterpret_cast<ELF::Rela*>(data->d_buf);
     std::vector<ELF::Rela> relocations(
         relocations_base,
         relocations_base + data->d_size / sizeof(relocations[0]));
 
     LOG(INFO) << "Relocations   : RELA";
-    return PackTypedRelocations<ELF::Rela>(relocations, data);
+    return PackTypedRelocations<ELF::Rela>(relocations);
   }
 
   NOTREACHED();
   return false;
 }
 
 // Helper for PackRelocations().  Rel type is one of ELF::Rel or ELF::Rela.
 template <typename Rel>
-bool ElfFile::PackTypedRelocations(const std::vector<Rel>& relocations,
-                                   Elf_Data* data) {
+bool ElfFile::PackTypedRelocations(const std::vector<Rel>& relocations) {
   // Filter relocations into those that are relative and others.
   std::vector<Rel> relative_relocations;
   std::vector<Rel> other_relocations;
 
   for (size_t i = 0; i < relocations.size(); ++i) {
     const Rel& relocation = relocations[i];
     if (ELF_R_TYPE(relocation.r_info) == ELF::kRelativeRelocationCode) {
       CHECK(ELF_R_SYM(relocation.r_info) == 0);
       relative_relocations.push_back(relocation);
     } else {
@@ skipping 90 matching lines @@
   if (packed_bytes >= initial_bytes) {
     LOG(INFO) << "Packing relative relocations saves no space";
     return false;
   }
 
   // Rewrite the current dynamic relocations section to be only the ARM
   // non-relative relocations, then shrink it to size.
   const void* section_data = &other_relocations[0];
   const size_t bytes = other_relocations.size() * sizeof(other_relocations[0]);
   ResizeSection<Rel>(elf_, relocations_section_, bytes);
-  RewriteSectionData(data, section_data, bytes);
+  RewriteSectionData(relocations_section_, section_data, bytes);
 
   // Rewrite the current packed android relocations section to hold the packed
   // relative relocations.
-  data = GetSectionData(android_relocations_section_);
   ResizeSection<Rel>(elf_, android_relocations_section_, packed_bytes);
-  RewriteSectionData(data, packed_data, packed_bytes);
+  RewriteSectionData(android_relocations_section_, packed_data, packed_bytes);
 
   // Rewrite .dynamic to include two new tags describing the packed android
   // relocations.
-  data = GetSectionData(dynamic_section_);
+  Elf_Data* data = GetSectionData(dynamic_section_);
   const ELF::Dyn* dynamic_base = reinterpret_cast<ELF::Dyn*>(data->d_buf);
   std::vector<ELF::Dyn> dynamics(
       dynamic_base,
       dynamic_base + data->d_size / sizeof(dynamics[0]));
   // Use two of the spare slots to describe the packed section.
   ELF::Shdr* section_header = ELF::getshdr(android_relocations_section_);
   {
     ELF::Dyn dyn;
     dyn.d_tag = DT_ANDROID_REL_OFFSET;
     dyn.d_un.d_ptr = section_header->sh_offset;
     AddDynamicEntry(dyn, &dynamics);
   }
   {
     ELF::Dyn dyn;
     dyn.d_tag = DT_ANDROID_REL_SIZE;
     dyn.d_un.d_val = section_header->sh_size;
     AddDynamicEntry(dyn, &dynamics);
   }
   const void* dynamics_data = &dynamics[0];
   const size_t dynamics_bytes = dynamics.size() * sizeof(dynamics[0]);
-  RewriteSectionData(data, dynamics_data, dynamics_bytes);
+  RewriteSectionData(dynamic_section_, dynamics_data, dynamics_bytes);
 
   Flush();
   return true;
 }
 
 // Find packed relative relocations in the packed android relocations
 // section, unpack them, and rewrite the dynamic relocations section to
 // contain unpacked data.
 bool ElfFile::UnpackRelocations() {
   // Load the ELF file into libelf.
@@ skipping 12 matching lines @@
       packed_base + data->d_size / sizeof(packed[0]));
 
   if (packed.size() > 3 &&
       packed[0] == 'A' &&
       packed[1] == 'P' &&
       packed[2] == 'R' &&
       packed[3] == '1') {
     // Signature is APR1, unpack relocations.
     CHECK(relocations_type_ == REL);
     LOG(INFO) << "Relocations   : REL";
-    return UnpackTypedRelocations<ELF::Rel>(packed, data);
+    return UnpackTypedRelocations<ELF::Rel>(packed);
   }
 
   if (packed.size() > 3 &&
       packed[0] == 'A' &&
       packed[1] == 'P' &&
       packed[2] == 'A' &&
       packed[3] == '1') {
     // Signature is APA1, unpack relocations with addends.
     CHECK(relocations_type_ == RELA);
     LOG(INFO) << "Relocations   : RELA";
-    return UnpackTypedRelocations<ELF::Rela>(packed, data);
+    return UnpackTypedRelocations<ELF::Rela>(packed);
   }
 
   LOG(ERROR) << "Packed relative relocations not found (not packed?)";
   return false;
 }
 
 // Helper for UnpackRelocations().  Rel type is one of ELF::Rel or ELF::Rela.
 template <typename Rel>
-bool ElfFile::UnpackTypedRelocations(const std::vector<uint8_t>& packed,
-                                     Elf_Data* data) {
+bool ElfFile::UnpackTypedRelocations(const std::vector<uint8_t>& packed) {
   // Unpack the data to re-materialize the relative relocations.
   const size_t packed_bytes = packed.size() * sizeof(packed[0]);
   LOG(INFO) << "Packed   relative: " << packed_bytes << " bytes";
   std::vector<Rel> relative_relocations;
   RelocationPacker packer;
   packer.UnpackRelativeRelocations(packed, &relative_relocations);
   const size_t unpacked_bytes =
       relative_relocations.size() * sizeof(relative_relocations[0]);
   LOG(INFO) << "Unpacked relative: " << unpacked_bytes << " bytes";
 
   // Retrieve the current dynamic relocations section data.
-  data = GetSectionData(relocations_section_);
+  Elf_Data* data = GetSectionData(relocations_section_);
 
   // Interpret data as relocations.
   const Rel* relocations_base = reinterpret_cast<Rel*>(data->d_buf);
   std::vector<Rel> relocations(
       relocations_base,
       relocations_base + data->d_size / sizeof(relocations[0]));
 
   std::vector<Rel> other_relocations;
   size_t padding = 0;
 
@@ skipping 31 matching lines @@
   // relocations followed by other relocations.  This is the usual order in
   // which we find them after linking, so this action will normally put the
   // entire dynamic relocations section back to its pre-split-and-packed state.
   relocations.assign(relative_relocations.begin(), relative_relocations.end());
   relocations.insert(relocations.end(),
                      other_relocations.begin(), other_relocations.end());
   const void* section_data = &relocations[0];
   const size_t bytes = relocations.size() * sizeof(relocations[0]);
   LOG(INFO) << "Total         : " << relocations.size() << " entries";
   ResizeSection<Rel>(elf_, relocations_section_, bytes);
-  RewriteSectionData(data, section_data, bytes);
+  RewriteSectionData(relocations_section_, section_data, bytes);
 
   // Nearly empty the current packed android relocations section.  Leaves a
   // four-byte stub so that some data remains allocated to the section.
   // This is a convenience which allows us to re-pack this file again without
   // having to remove the section and then add a new small one with objcopy.
   // The way we resize sections relies on there being some data in a section.
-  data = GetSectionData(android_relocations_section_);
   ResizeSection<Rel>(
       elf_, android_relocations_section_, sizeof(kStubIdentifier));
-  RewriteSectionData(data, &kStubIdentifier, sizeof(kStubIdentifier));
+  RewriteSectionData(
+      android_relocations_section_, &kStubIdentifier, sizeof(kStubIdentifier));
 
   // Rewrite .dynamic to remove two tags describing packed android relocations.
   data = GetSectionData(dynamic_section_);
   const ELF::Dyn* dynamic_base = reinterpret_cast<ELF::Dyn*>(data->d_buf);
   std::vector<ELF::Dyn> dynamics(
       dynamic_base,
       dynamic_base + data->d_size / sizeof(dynamics[0]));
   RemoveDynamicEntry(DT_ANDROID_REL_OFFSET, &dynamics);
   RemoveDynamicEntry(DT_ANDROID_REL_SIZE, &dynamics);
   const void* dynamics_data = &dynamics[0];
   const size_t dynamics_bytes = dynamics.size() * sizeof(dynamics[0]);
-  RewriteSectionData(data, dynamics_data, dynamics_bytes);
+  RewriteSectionData(dynamic_section_, dynamics_data, dynamics_bytes);
 
   Flush();
   return true;
 }
 
 // Flush rewritten shared object file data.
 void ElfFile::Flush() {
   // Flag all ELF data held in memory as needing to be written back to the
   // file, and tell libelf that we have controlled the file layout.
   elf_flagelf(elf_, ELF_C_SET, ELF_F_DIRTY);
   elf_flagelf(elf_, ELF_C_SET, ELF_F_LAYOUT);
 
   // Write ELF data back to disk.
   const off_t file_bytes = elf_update(elf_, ELF_C_WRITE);
   CHECK(file_bytes > 0);
   VLOG(1) << "elf_update returned: " << file_bytes;
 
   // Clean up libelf, and truncate the output file to the number of bytes
   // written by elf_update().
   elf_end(elf_);
   elf_ = NULL;
   const int truncate = ftruncate(fd_, file_bytes);
   CHECK(truncate == 0);
 }
 
 }  // namespace relocation_packer