Preserve section and data alignment in libchrome.<ver>.so.

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.
 
 // TODO(simonb): Extend for 64-bit target libraries.
 
 #include "elf_file.h"
 
 #include <stdlib.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <string>
 #include <vector>
 
 #include "debug.h"
 #include "libelf.h"
 #include "packer.h"
 
 namespace relocation_packer {
 
 // Stub identifier written to 'null out' packed data, "NULL".
 static const Elf32_Word kStubIdentifier = 0x4c4c554eu;
 
 // Out-of-band dynamic tags used to indicate the offset and size of the
 // .android.rel.dyn section.
 static const Elf32_Sword DT_ANDROID_ARM_REL_OFFSET = DT_LOPROC;
 static const Elf32_Sword DT_ANDROID_ARM_REL_SIZE = DT_LOPROC + 1;
 
+// Alignment to preserve, in bytes.  This must be at least as large as the
+// largest d_align and sh_addralign values found in the loaded file.
+static const size_t kPreserveAlignment = 256;
+
 namespace {
 
 // Get section data.  Checks that the section has exactly one data entry,
 // so that the section size and the data size are the same.  True in
 // practice for all sections we resize when packing or unpacking.  Done
 // 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);
@@ skipping 45 matching lines @@
   VLOG("  p_memsz = %u\n", program_header->p_memsz);
 }
 
 // Verbose ELF section header logging.
 void VerboseLogSectionHeader(const std::string& section_name,
                              const Elf32_Shdr* section_header) {
   VLOG("section %s\n", section_name.c_str());
   VLOG("  sh_addr = %u\n", section_header->sh_addr);
   VLOG("  sh_offset = %u\n", section_header->sh_offset);
   VLOG("  sh_size = %u\n", section_header->sh_size);
+  VLOG("  sh_addralign = %u\n", section_header->sh_addralign);
 }
 
 // Verbose ELF section data logging.
 void VerboseLogSectionData(const Elf_Data* data) {
   VLOG("  data\n");
   VLOG("    d_buf = %p\n", data->d_buf);
   VLOG("    d_off = %lu\n", data->d_off);
   VLOG("    d_size = %lu\n", data->d_size);
+  VLOG("    d_align = %lu\n", data->d_align);
 }
 
 }  // namespace
 
 // Load the complete ELF file into a memory image in libelf, and identify
 // the .rel.dyn, .dynamic, and .android.rel.dyn sections.  No-op if the
 // ELF file has already been loaded.
 bool ElfFile::Load() {
   if (elf_)
     return true;
@@ skipping 71 matching lines @@
     }
     if (section_header->sh_offset == dynamic_program_header->p_offset) {
       found_dynamic_section = section;
     }
 
     // If we find a section named .debug*, set the debug warning flag.
     if (std::string(name).find(".debug") == 0) {
       has_debug_section = true;
     }
 
+    // Ensure we preserve alignment, repeated later for the data block(s).
+    CHECK(section_header->sh_addralign <= kPreserveAlignment);
+
     Elf_Data* data = NULL;
     while ((data = elf_getdata(section, data)) != NULL) {
+      CHECK(data->d_align <= kPreserveAlignment);
       VerboseLogSectionData(data);
     }
   }
 
   // Loading failed if we did not find the required special sections.
   if (!found_rel_dyn_section) {
     LOG("ERROR: Missing .rel.dyn section\n");
     return false;
   }
   if (!found_dynamic_section) {
@@ skipping 442 matching lines @@
       CHECK(ELF32_R_TYPE(relocation->r_info) == R_ARM_RELATIVE);
 
       // See if this relocation points into the current section.
       if (relocation->r_offset >= section_start &&
           relocation->r_offset < section_end) {
         Elf32_Addr byte_offset = relocation->r_offset - section_start;
         Elf32_Off* target = reinterpret_cast<Elf32_Off*>(area + byte_offset);
 
         // Is the relocation's target after the hole's start?
         if (*target > hole_start) {
-
           // Copy on first write.  Recompute target to point into the newly
           // allocated buffer.
           if (area == data->d_buf) {
             area = new uint8_t[data->d_size];
             memcpy(area, data->d_buf, data->d_size);
             target = reinterpret_cast<Elf32_Off*>(area + byte_offset);
           }
 
           *target += hole_size;
           VLOG("relocation[%lu] target adjusted to %u\n", i, *target);
         }
       }
     }
 
     // If we applied any relocation to this section, write it back.
     if (area != data->d_buf) {
       RewriteSectionData(data, area, data->d_size);
       delete [] area;
     }
   }
 }
 
+// Pad relocations with a given number of R_ARM_NONE relocations.
+void PadRelocations(size_t count,
+                    std::vector<Elf32_Rel>* relocations) {
+  const Elf32_Rel r_arm_none = {R_ARM_NONE, 0};
+  std::vector<Elf32_Rel> padding(count, r_arm_none);
+  relocations->insert(relocations->end(), padding.begin(), padding.end());
+}
+
 // Adjust relocations so that the offset that they indicate will be correct
 // after the hole in .rel.dyn is added or removed (in effect, relocate the
 // relocations).
 void AdjustRelocations(Elf32_Off hole_start,
                        size_t hole_size,
                        std::vector<Elf32_Rel>* relocations) {
   for (size_t i = 0; i < relocations->size(); ++i) {
     Elf32_Rel* relocation = &relocations->at(i);
     if (relocation->r_offset > hole_start) {
       relocation->r_offset += hole_size;
@@ skipping 28 matching lines @@
   // Filter relocations into those that are R_ARM_RELATIVE and others.
   for (size_t i = 0; i < relocations.size(); ++i) {
     const Elf32_Rel& relocation = relocations[i];
     if (ELF32_R_TYPE(relocation.r_info) == R_ARM_RELATIVE) {
       CHECK(ELF32_R_SYM(relocation.r_info) == 0);
       relative_relocations.push_back(relocation);
     } else {
       other_relocations.push_back(relocation);
     }
   }
-  VLOG("R_ARM_RELATIVE: %lu entries\n", relative_relocations.size());
-  VLOG("Other         : %lu entries\n", other_relocations.size());
-  VLOG("Total         : %lu entries\n", relocations.size());
+  LOG("R_ARM_RELATIVE: %lu entries\n", relative_relocations.size());
+  LOG("Other         : %lu entries\n", other_relocations.size());
+  LOG("Total         : %lu entries\n", relocations.size());
 
   // If no relative relocations then we have nothing packable.  Perhaps
   // the shared object has already been packed?
   if (relative_relocations.empty()) {
     LOG("ERROR: No R_ARM_RELATIVE relocations found (already packed?)\n");
     return false;
   }
 
-  // Pre-calculate the size of the hole we will close up when we rewrite
-  // .reldyn.  We have to adjust all relocation addresses to account for this.
-  Elf32_Shdr* section_header = elf32_getshdr(rel_dyn_section_);
-  const Elf32_Off hole_start = section_header->sh_offset;
-  const size_t hole_size =
-      relative_relocations.size() * sizeof(relative_relocations[0]);
-
   // Unless padding, pre-apply R_ARM_RELATIVE relocations to account for the
   // hole, and pre-adjust all relocation offsets accordingly.
   if (!is_padding_rel_dyn_) {
+    // Pre-calculate the size of the hole we will close up when we rewrite
+    // .rel.dyn.  We have to adjust relocation addresses to account for this.
+    Elf32_Shdr* section_header = elf32_getshdr(rel_dyn_section_);
+    const Elf32_Off hole_start = section_header->sh_offset;
+    size_t hole_size =
+        relative_relocations.size() * sizeof(relative_relocations[0]);
+    const size_t unaligned_hole_size = hole_size;
+
+    // Adjust the actual hole size to preserve alignment.
+    hole_size -= hole_size % kPreserveAlignment;
+    LOG("Compaction    : %lu bytes\n", hole_size);
+
+    // Adjusting for alignment may have removed any packing benefit.
+    if (hole_size == 0) {
+      LOG("Too few R_ARM_RELATIVE relocations to pack after alignment\n");
+      return false;
+    }
+
+    // Add R_ARM_NONE relocations to other_relocations to preserve alignment.
+    const size_t padding_bytes = unaligned_hole_size - hole_size;
+    CHECK(padding_bytes % sizeof(other_relocations[0]) == 0);
+    const size_t required = padding_bytes / sizeof(other_relocations[0]);
+    PadRelocations(required, &other_relocations);
+    LOG("Alignment pad : %lu relocations\n", required);
+
     // Apply relocations to all R_ARM_RELATIVE data to relocate it into the
     // area it will occupy once the hole in .rel.dyn is removed.
     AdjustRelocationTargets(elf_, hole_start, -hole_size, relative_relocations);
     // Relocate the relocations.
     AdjustRelocations(hole_start, -hole_size, &relative_relocations);
     AdjustRelocations(hole_start, -hole_size, &other_relocations);
   }
 
   // Pack R_ARM_RELATIVE relocations.
   const size_t initial_bytes =
@@ skipping 24 matching lines @@
 
   // Make sure packing saved some space.
   if (packed_bytes >= initial_bytes) {
     LOG("Packing R_ARM_RELATIVE relocations saves no space\n");
     return false;
   }
 
   // If padding, add R_ARM_NONE relocations to other_relocations to make it
   // the same size as the the original relocations we read in.  This makes
   // the ResizeSection() below a no-op.
   if (is_padding_rel_dyn_) {

[rmcilroy, 2014/06/18 09:52:29]

Could you just do this in the "else" block of the above "if
(!is_padding_rel_dyn_)" ? I think this would be clearer if possible.

[simonb1, 2014/06/18 11:30:19]

Done.

-    const Elf32_Rel r_arm_none = {R_ARM_NONE, 0};
     const size_t required = relocations.size() - other_relocations.size();
-    std::vector<Elf32_Rel> padding(required, r_arm_none);
-    other_relocations.insert(
-        other_relocations.end(), padding.begin(), padding.end());
+    PadRelocations(required, &other_relocations);
   }
 
   // Rewrite the current .rel.dyn section to be only the non-R_ARM_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(elf_, rel_dyn_section_, bytes);

[rmcilroy, 2014/06/18 09:52:29]

Do you need to pad this to kPreserveAlignment as well to ensure that the
sections following  .rel.dyn are also aligned?

[simonb1, 2014/06/18 11:30:19]

Shouldn't.  The R_ARM_NONE padding in other_relocations (line 781) is what
ensures that sections following .rel.dyn retain their present alignments.  Put
differently, I'm ensuring that the hole removed from the file does not disturb
any alignments; that means aligning the hole size rather than the remaining
data.  (The alignment of .rel.dyn itself is 4 bytes, and relocation elements are
each 8 bytes.)

[rmcilroy, 2014/06/18 13:01:07]

Sorry - see below.

   RewriteSectionData(data, section_data, bytes);
 
   // Rewrite the current .android.rel.dyn section to hold the packed
   // R_ARM_RELATIVE relocations.
   data = GetSectionData(android_rel_dyn_section_);
   ResizeSection(elf_, android_rel_dyn_section_, packed_bytes);
   RewriteSectionData(data, packed_data, packed_bytes);

[rmcilroy, 2014/06/18 13:01:07]

Sorry I got the comment on the wrong line - I was meaning here, should we be
ensuring the size added to android.rel.dyn keeps all the following sections
aligned?

[simonb1, 2014/06/18 13:29:09]

Happily, no.  Libbfd locates .android.rel.dyn as the penultimate section.  That
is, at then end of data sections and just before the final .shstrtab section. 
And both .android.rel.dyn and .shstrtab have alignment of 1.

 
   // Rewrite .dynamic to include two new tags describing .android.rel.dyn.
   data = GetSectionData(dynamic_section_);
   const Elf32_Dyn* dynamic_base = reinterpret_cast<Elf32_Dyn*>(data->d_buf);
   std::vector<Elf32_Dyn> dynamics(
       dynamic_base,
       dynamic_base + data->d_size / sizeof(dynamics[0]));
-  section_header = elf32_getshdr(android_rel_dyn_section_);
+  Elf32_Shdr* section_header = elf32_getshdr(android_rel_dyn_section_);
   // Use two of the spare slots to describe the .android.rel.dyn section.
   const Elf32_Dyn offset_dyn
       = {DT_ANDROID_ARM_REL_OFFSET, {section_header->sh_offset}};
   AddDynamicEntry(offset_dyn, &dynamics);
   const Elf32_Dyn size_dyn
       = {DT_ANDROID_ARM_REL_SIZE, {section_header->sh_size}};
   AddDynamicEntry(size_dyn, &dynamics);
   const void* dynamics_data = &dynamics[0];
   const size_t dynamics_bytes = dynamics.size() * sizeof(dynamics[0]);
   RewriteSectionData(data, dynamics_data, dynamics_bytes);
@@ skipping 60 matching lines @@
       ++padding;
     }
   }
   LOG("R_ARM_RELATIVE: %lu entries\n", relative_relocations.size());
   LOG("Other         : %lu entries\n", other_relocations.size());
 
   // If we found the same number of R_ARM_NONE entries in .rel.dyn as we
   // hold as unpacked relative relocations, then this is a padded file.
   const bool is_padded = padding == relative_relocations.size();
 
-  // Pre-calculate the size of the hole we will open up when we rewrite
-  // .reldyn.  We have to adjust all relocation addresses to account for this.
-  Elf32_Shdr* section_header = elf32_getshdr(rel_dyn_section_);
-  const Elf32_Off hole_start = section_header->sh_offset;
-  const size_t hole_size =
-      relative_relocations.size() * sizeof(relative_relocations[0]);
-
   // Unless padded, pre-apply R_ARM_RELATIVE relocations to account for the
   // hole, and pre-adjust all relocation offsets accordingly.
   if (!is_padded) {
+    // Pre-calculate the size of the hole we will open up when we rewrite
+    // .rel.dyn.  We have to adjust relocation addresses to account for this.
+    Elf32_Shdr* section_header = elf32_getshdr(rel_dyn_section_);
+    const Elf32_Off hole_start = section_header->sh_offset;
+    size_t hole_size =
+        relative_relocations.size() * sizeof(relative_relocations[0]);
+
+    // Adjust the hole size for the padding added to preserve alignment.
+    hole_size -= padding * sizeof(other_relocations[0]);
+    LOG("Expansion     : %lu bytes\n", hole_size);
+
     // Apply relocations to all R_ARM_RELATIVE data to relocate it into the
     // area it will occupy once the hole in .rel.dyn is opened.
     AdjustRelocationTargets(elf_, hole_start, hole_size, relative_relocations);
     // Relocate the relocations.
     AdjustRelocations(hole_start, hole_size, &relative_relocations);
     AdjustRelocations(hole_start, hole_size, &other_relocations);
   }
 
   // Rewrite the current .rel.dyn section to be the R_ARM_RELATIVE relocations
   // followed by other relocations.  This is the usual order in which we find
@@ skipping 47 matching lines @@
 
   // 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