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);
+  } else {
+    // 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.
+    const size_t required = relocations.size() - other_relocations.size();
+    PadRelocations(required, &other_relocations);
   }
 
+
   // Pack R_ARM_RELATIVE relocations.
   const size_t initial_bytes =
       relative_relocations.size() * sizeof(relative_relocations[0]);
   LOG("Unpacked R_ARM_RELATIVE: %lu bytes\n", initial_bytes);
   std::vector<uint8_t> packed;
   RelocationPacker packer;
   packer.PackRelativeRelocations(relative_relocations, &packed);
   const void* packed_data = &packed[0];
   const size_t packed_bytes = packed.size() * sizeof(packed[0]);
   LOG("Packed   R_ARM_RELATIVE: %lu bytes\n", packed_bytes);
@@ skipping 13 matching lines @@
     CHECK(unpacked[i].r_offset == relative_relocations[i].r_offset);
     CHECK(unpacked[i].r_info == relative_relocations[i].r_info);
   }
 
   // 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_) {
-    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());
-  }
-
   // 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);
   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);
 
   // 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