Alter how relocation packing cuts holes from libchrome.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.
 
+// 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
+// the shared library.
+//
+// Arranging this means that we have to split one of the LOAD segments into
+// two.  Unfortunately, the program headers are located at the very start
+// of the shared library file, so expanding the program header section
+// would cause a lot of consequent changes to files offsets that we don't
+// really want to have to handle.
+//
+// Luckily, though, there is a segment that is always present and always
+// unused on Android; the GNU_STACK segment.  What we do is to steal that
+// and repurpose it to be one of the split LOAD segments.  We then have to
+// sort LOAD segments by offset to keep the crazy linker happy.
+//
+// All of this takes place in SplitProgramHeadersForHole(), used on packing,
+// and is unraveled on unpacking in CoalesceProgramHeadersForHole().  See
+// commentary on those functions for an example of this segment stealing
+// in action.
+
 #include "elf_file.h"
 
 #include <stdlib.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <algorithm>
 #include <string>
 #include <vector>
 
 #include "debug.h"
 #include "elf_traits.h"
 #include "libelf.h"
 #include "packer.h"
 
 namespace relocation_packer {
 
@@ skipping 48 matching lines @@
 
 // Verbose ELF program header logging.
 void VerboseLogProgramHeader(size_t program_header_index,
                              const ELF::Phdr* program_header) {
   std::string type;
   switch (program_header->p_type) {
     case PT_NULL: type = "NULL"; break;
     case PT_LOAD: type = "LOAD"; break;
     case PT_DYNAMIC: type = "DYNAMIC"; break;
     case PT_INTERP: type = "INTERP"; break;
-    case PT_NOTE: type = "NOTE"; break;
-    case PT_SHLIB: type = "SHLIB"; break;
     case PT_PHDR: type = "PHDR"; break;
-    case PT_TLS: type = "TLS"; break;
+    case PT_GNU_RELRO: type = "GNU_RELRO"; break;
+    case PT_GNU_STACK: type = "GNU_STACK"; break;
+    case PT_ARM_EXIDX: type = "EXIDX"; break;
     default: type = "(OTHER)"; break;
   }
-  VLOG(1) << "phdr " << program_header_index << " : " << type;
+  VLOG(1) << "phdr[" << program_header_index << "] : " << type;
   VLOG(1) << "  p_offset = " << program_header->p_offset;
   VLOG(1) << "  p_vaddr = " << program_header->p_vaddr;
   VLOG(1) << "  p_paddr = " << program_header->p_paddr;
   VLOG(1) << "  p_filesz = " << program_header->p_filesz;
   VLOG(1) << "  p_memsz = " << program_header->p_memsz;
+  VLOG(1) << "  p_flags = " << program_header->p_flags;
+  VLOG(1) << "  p_align = " << program_header->p_align;
 }
 
 // Verbose ELF section header logging.
 void VerboseLogSectionHeader(const std::string& section_name,
                              const ELF::Shdr* section_header) {
   VLOG(1) << "section " << section_name;
   VLOG(1) << "  sh_addr = " << section_header->sh_addr;
   VLOG(1) << "  sh_offset = " << section_header->sh_offset;
   VLOG(1) << "  sh_size = " << section_header->sh_size;
   VLOG(1) << "  sh_addralign = " << section_header->sh_addralign;
@@ skipping 75 matching lines @@
   // attributes.
   Elf_Scn* found_relocations_section = NULL;
   Elf_Scn* found_android_relocations_section = NULL;
   Elf_Scn* found_dynamic_section = NULL;
 
   // Notes of relocation section types seen.  We require one or the other of
   // these; both is unsupported.
   bool has_rel_relocations = false;
   bool has_rela_relocations = false;
 
-  // Flag set if we encounter any .debug* section.  We do not adjust any
-  // offsets or addresses of any debug data, so if we find one of these then
-  // the resulting output shared object should still run, but might not be
-  // usable for debugging, disassembly, and so on.  Provides a warning if
-  // this occurs.
-  bool has_debug_section = false;
-
   Elf_Scn* section = NULL;
   while ((section = elf_nextscn(elf, section)) != NULL) {
     const ELF::Shdr* section_header = ELF::getshdr(section);
     std::string name = elf_strptr(elf, string_index, section_header->sh_name);
     VerboseLogSectionHeader(name, section_header);
 
     // Note relocation section types.
     if (section_header->sh_type == SHT_REL) {
       has_rel_relocations = true;
     }
     if (section_header->sh_type == SHT_RELA) {
       has_rela_relocations = true;
     }
 
     // Note special sections as we encounter them.
     if ((name == ".rel.dyn" || name == ".rela.dyn") &&
         section_header->sh_size > 0) {
       found_relocations_section = section;
     }
     if ((name == ".android.rel.dyn" || name == ".android.rela.dyn") &&
         section_header->sh_size > 0) {
       found_android_relocations_section = section;
     }
     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);
     }
   }
 
@@ skipping 17 matching lines @@
   if (!has_rel_relocations && !has_rela_relocations) {
     LOG(ERROR) << "No relocations sections found";
     return false;
   }
   if (has_rel_relocations && has_rela_relocations) {
     LOG(ERROR) << "Multiple relocations sections with different types found, "
                << "not currently supported";
     return false;
   }
 
-  if (has_debug_section) {
-    LOG(WARNING) << "Found .debug section(s), and ignored them";
-  }
-
   elf_ = elf;
   relocations_section_ = found_relocations_section;
   dynamic_section_ = found_dynamic_section;
   android_relocations_section_ = found_android_relocations_section;
   relocations_type_ = has_rel_relocations ? REL : RELA;
   return true;
 }
 
 namespace {
 
 // Helper for ResizeSection().  Adjust the main ELF header for the hole.
 void AdjustElfHeaderForHole(ELF::Ehdr* elf_header,
                             ELF::Off hole_start,
                             ssize_t hole_size) {
   if (elf_header->e_phoff > hole_start) {
     elf_header->e_phoff += hole_size;
     VLOG(1) << "e_phoff adjusted to " << elf_header->e_phoff;
   }
   if (elf_header->e_shoff > hole_start) {
     elf_header->e_shoff += hole_size;
     VLOG(1) << "e_shoff adjusted to " << elf_header->e_shoff;
   }
 }
 
-// Helper for ResizeSection().  Adjust all program headers for the hole.
-void AdjustProgramHeadersForHole(ELF::Phdr* elf_program_header,
-                                 size_t program_header_count,
-                                 ELF::Off hole_start,
-                                 ssize_t hole_size) {
-  for (size_t i = 0; i < program_header_count; ++i) {
-    ELF::Phdr* program_header = &elf_program_header[i];
-
-    if (program_header->p_offset > hole_start) {
-      // The hole start is past this segment, so adjust offsets and addrs.
-      program_header->p_offset += hole_size;
-      VLOG(1) << "phdr " << i
-              << " p_offset adjusted to "<< program_header->p_offset;
-
-      // Only adjust vaddr and paddr if this program header has them.
-      if (program_header->p_vaddr != 0) {
-        program_header->p_vaddr += hole_size;
-        VLOG(1) << "phdr " << i
-                << " p_vaddr adjusted to " << program_header->p_vaddr;
-      }
-      if (program_header->p_paddr != 0) {
-        program_header->p_paddr += hole_size;
-        VLOG(1) << "phdr " << i
-                << " p_paddr adjusted to " << program_header->p_paddr;
-      }
-    } else if (program_header->p_offset +
-               program_header->p_filesz > hole_start) {
-      // The hole start is within this segment, so adjust file and in-memory
-      // sizes, but leave offsets and addrs unchanged.
-      program_header->p_filesz += hole_size;
-      VLOG(1) << "phdr " << i
-              << " p_filesz adjusted to " << program_header->p_filesz;
-      program_header->p_memsz += hole_size;
-      VLOG(1) << "phdr " << i
-              << " p_memsz adjusted to " << program_header->p_memsz;
-    }
-  }
-}
-
 // Helper for ResizeSection().  Adjust all section headers for the hole.
 void AdjustSectionHeadersForHole(Elf* elf,
                                  ELF::Off hole_start,
                                  ssize_t hole_size) {
   size_t string_index;
   elf_getshdrstrndx(elf, &string_index);
 
   Elf_Scn* section = NULL;
   while ((section = elf_nextscn(elf, section)) != NULL) {
     ELF::Shdr* section_header = ELF::getshdr(section);
     std::string name = elf_strptr(elf, string_index, section_header->sh_name);
 
     if (section_header->sh_offset > hole_start) {
       section_header->sh_offset += hole_size;
       VLOG(1) << "section " << name
               << " sh_offset adjusted to " << section_header->sh_offset;
-      // Only adjust section addr if this section has one.
-      if (section_header->sh_addr != 0) {
-        section_header->sh_addr += hole_size;
-        VLOG(1) << "section " << name
-                << " sh_addr adjusted to " << section_header->sh_addr;
+    }
+  }
+}
+
+// Helper for ResizeSection().  Adjust the offsets of any program headers
+// that have offsets currently beyond the hole start.
+void AdjustProgramHeaderOffsets(ELF::Phdr* program_headers,
+                                size_t count,
+                                ELF::Phdr* ignored_1,
+                                ELF::Phdr* ignored_2,
+                                ELF::Off hole_start,
+                                ssize_t hole_size) {
+  for (size_t i = 0; i < count; ++i) {
+    ELF::Phdr* program_header = &program_headers[i];
+
+    if (program_header == ignored_1 || program_header == ignored_2)
+      continue;
+
+    if (program_header->p_offset > hole_start) {
+      // The hole start is past this segment, so adjust offset.
+      program_header->p_offset += hole_size;
+      VLOG(1) << "phdr[" << i
+              << "] p_offset adjusted to "<< program_header->p_offset;
+    }
+  }
+}
+
+// Helper for ResizeSection().  Find the first loadable segment in the
+// file.  We expect it to map from file offset zero.
+ELF::Phdr* FindFirstLoadSegment(ELF::Phdr* program_headers,
+                                size_t count) {
+  ELF::Phdr* first_loadable_segment = NULL;
+
+  for (size_t i = 0; i < count; ++i) {
+    ELF::Phdr* program_header = &program_headers[i];
+
+    if (program_header->p_type == PT_LOAD &&
+        program_header->p_offset == 0 &&
+        program_header->p_vaddr == 0 &&
+        program_header->p_paddr == 0) {
+      first_loadable_segment = program_header;
+    }
+  }
+  LOG_IF(FATAL, !first_loadable_segment)
+      << "Cannot locate a LOAD segment with address and offset zero";
+
+  return first_loadable_segment;
+}
+
+// Helper for ResizeSection().  Find the PT_GNU_STACK segment, and check
+// that it contains what we expect so we can restore it on unpack if needed.
+ELF::Phdr* FindUnusedGnuStackSegment(ELF::Phdr* program_headers,
+                                     size_t count) {
+  ELF::Phdr* unused_segment = NULL;
+
+  for (size_t i = 0; i < count; ++i) {
+    ELF::Phdr* program_header = &program_headers[i];
+
+    if (program_header->p_type == PT_GNU_STACK &&
+        program_header->p_offset == 0 &&
+        program_header->p_vaddr == 0 &&
+        program_header->p_paddr == 0 &&
+        program_header->p_filesz == 0 &&
+        program_header->p_memsz == 0 &&
+        program_header->p_flags == (PF_R | PF_W) &&
+        program_header->p_align == ELF::kGnuStackSegmentAlignment) {
+      unused_segment = program_header;
+    }
+  }
+  LOG_IF(FATAL, !unused_segment)
+      << "Cannot locate the expected GNU_STACK segment";
+
+  return unused_segment;
+}
+
+// Helper for ResizeSection().  Find the segment that was the first loadable
+// one before we split it into two.  This is the one into which we coalesce
+// the split segments on unpacking.
+ELF::Phdr* FindOriginalFirstLoadSegment(ELF::Phdr* program_headers,
+                                        size_t count) {
+  const ELF::Phdr* first_loadable_segment =
+      FindFirstLoadSegment(program_headers, count);
+
+  ELF::Phdr* original_first_loadable_segment = NULL;
+
+  for (size_t i = 0; i < count; ++i) {
+    ELF::Phdr* program_header = &program_headers[i];
+
+    // The original first loadable segment is the one that follows on from
+    // the one we wrote on split to be the current first loadable segment.
+    if (program_header->p_type == PT_LOAD &&
+        program_header->p_offset == first_loadable_segment->p_filesz) {
+      original_first_loadable_segment = program_header;
+    }
+  }
+  LOG_IF(FATAL, !original_first_loadable_segment)
+      << "Cannot locate the LOAD segment that follows a LOAD at offset zero";
+
+  return original_first_loadable_segment;
+}
+
+// Helper for ResizeSection().  Find the segment that contains the hole.
+Elf_Scn* FindSectionContainingHole(Elf* elf,
+                                   ELF::Off hole_start,
+                                   ssize_t hole_size) {
+  Elf_Scn* section = NULL;
+  Elf_Scn* last_unholed_section = NULL;
+
+  while ((section = elf_nextscn(elf, section)) != NULL) {
+    const ELF::Shdr* section_header = ELF::getshdr(section);
+
+    // Because we get here after section headers have been adjusted for the
+    // hole, we need to 'undo' that adjustment to give a view of the original
+    // sections layout.
+    ELF::Off offset = section_header->sh_offset;
+    if (section_header->sh_offset >= hole_start) {
+      offset -= hole_size;
+    }
+
+    if (offset <= hole_start) {
+      last_unholed_section = section;
+    }
+  }
+  LOG_IF(FATAL, !last_unholed_section)
+      << "Cannot identify the section before the one containing the hole";
+
+  // The section containing the hole is the one after the last one found
+  // by the loop above.
+  Elf_Scn* holed_section = elf_nextscn(elf, last_unholed_section);
+  LOG_IF(FATAL, !holed_section)
+      << "Cannot identify the section containing the hole";
+
+  return holed_section;
+}
+
+// Helper for ResizeSection().  Find the last section contained in a segment.
+Elf_Scn* FindLastSectionInSegment(Elf* elf,
+                                  ELF::Phdr* program_header,
+                                  ELF::Off hole_start,
+                                  ssize_t hole_size) {
+  const ELF::Off segment_end =
+      program_header->p_offset + program_header->p_filesz;
+
+  Elf_Scn* section = NULL;
+  Elf_Scn* last_section = NULL;
+
+  while ((section = elf_nextscn(elf, section)) != NULL) {
+    const ELF::Shdr* section_header = ELF::getshdr(section);
+
+    // As above, 'undo' any section offset adjustment to give a view of the
+    // original sections layout.
+    ELF::Off offset = section_header->sh_offset;
+    if (section_header->sh_offset >= hole_start) {
+      offset -= hole_size;
+    }
+
+    if (offset < segment_end) {
+      last_section = section;
+    }
+  }
+  LOG_IF(FATAL, !last_section)
+      << "Cannot identify the last section in the given segment";
+
+  return last_section;
+}
+
+// Helper for ResizeSection().  Order loadable segments by their offsets.
+// The crazy linker contains assumptions about loadable segment ordering,
+// and it is better if we do not break them.
+void SortOrderSensitiveProgramHeaders(ELF::Phdr* program_headers,
+                                      size_t count) {
+  std::vector<ELF::Phdr*> orderable;
+
+  // Collect together orderable program headers.  These are all the LOAD
+  // segments, and any GNU_STACK that may be present (removed on packing,
+  // but replaced on unpacking).
+  for (size_t i = 0; i < count; ++i) {
+    ELF::Phdr* program_header = &program_headers[i];
+
+    if (program_header->p_type == PT_LOAD ||
+        program_header->p_type == PT_GNU_STACK) {
+      orderable.push_back(program_header);
+    }
+  }
+
+  // Order these program headers so that any PT_GNU_STACK is last, and
+  // the LOAD segments that precede it appear in offset order.  Uses
+  // insertion sort.
+  for (size_t i = 1; i < orderable.size(); ++i) {
+    for (size_t j = i; j > 0; --j) {
+      ELF::Phdr* first = orderable[j - 1];
+      ELF::Phdr* second = orderable[j];
+
+      if (!(first->p_type == PT_GNU_STACK ||
+            first->p_offset > second->p_offset)) {
+        break;
       }
-    }
-  }
+      std::swap(*first, *second);
+    }
+  }
+}
+
+// Helper for ResizeSection().  The GNU_STACK program header is unused in
+// Android, so we can repurpose it here.  Before packing, the program header
+// table contains something like:
+//
+//   Type      Offset    VirtAddr   PhysAddr   FileSiz   MemSiz    Flg Align
+//   LOAD      0x000000  0x00000000 0x00000000 0x1efc818 0x1efc818 R E 0x1000
+//   LOAD      0x1efd008 0x01efe008 0x01efe008 0x17ec3c  0x1a0324  RW  0x1000
+//   DYNAMIC   0x205ec50 0x0205fc50 0x0205fc50 0x00108   0x00108   RW  0x4
+//   GNU_STACK 0x000000  0x00000000 0x00000000 0x00000   0x00000   RW  0
+//
+// The hole in the file is in the first of these.  In order to preserve all
+// load addresses, what we do is to turn the GNU_STACK into a new LOAD entry
+// that maps segments up to where we created the hole, adjust the first LOAD
+// entry so that it maps segments after that, adjust any other program
+// headers whose offset is after the hole start, and finally order the LOAD
+// segments by offset, to give:
+//
+//   Type      Offset    VirtAddr   PhysAddr   FileSiz   MemSiz    Flg Align
+//   LOAD      0x000000  0x00000000 0x00000000 0x14ea4   0x212ea4  R E 0x1000
+//   LOAD      0x014ea4  0x00212ea4 0x00212ea4 0x1cea164 0x1cea164 R E 0x1000
+//   DYNAMIC   0x1e60c50 0x0205fc50 0x0205fc50 0x00108   0x00108   RW  0x4
+//   LOAD      0x1cff008 0x01efe008 0x01efe008 0x17ec3c  0x1a0324  RW  0x1000
+//
+// We work out the split points by finding the .rel.dyn or .rela.dyn section
+// that contains the hole, and by finding the last section in a given segment.
+//
+// To unpack, we reverse the above to leave the file as it was originally.
+void SplitProgramHeadersForHole(Elf* elf,
+                                ELF::Off hole_start,
+                                ssize_t hole_size) {
+  CHECK(hole_size < 0);
+  const ELF::Ehdr* elf_header = ELF::getehdr(elf);
+  CHECK(elf_header);
+
+  ELF::Phdr* elf_program_header = ELF::getphdr(elf);
+  CHECK(elf_program_header);
+
+  const size_t program_header_count = elf_header->e_phnum;
+
+  // Locate the segment that we can overwrite to form the new LOAD entry,
+  // and the segment that we are going to split into two parts.
+  ELF::Phdr* spliced_header =
+      FindUnusedGnuStackSegment(elf_program_header, program_header_count);
+  ELF::Phdr* split_header =
+      FindFirstLoadSegment(elf_program_header, program_header_count);
+
+  VLOG(1) << "phdr[" << split_header - elf_program_header << "] split";
+  VLOG(1) << "phdr[" << spliced_header - elf_program_header << "] new LOAD";
+
+  // Find the section that contains the hole.  We split on the section that
+  // follows it.
+  Elf_Scn* holed_section =
+      FindSectionContainingHole(elf, hole_start, hole_size);
+
+  size_t string_index;
+  elf_getshdrstrndx(elf, &string_index);
+
+  ELF::Shdr* section_header = ELF::getshdr(holed_section);
+  std::string name = elf_strptr(elf, string_index, section_header->sh_name);
+  VLOG(1) << "section " << name << " split after";
+
+  // Find the last section in the segment we are splitting.
+  Elf_Scn* last_section =
+      FindLastSectionInSegment(elf, split_header, hole_start, hole_size);
+
+  section_header = ELF::getshdr(last_section);
+  name = elf_strptr(elf, string_index, section_header->sh_name);
+  VLOG(1) << "section " << name << " split end";
+
+  // Split on the section following the holed one, and up to (but not
+  // including) the section following the last one in the split segment.
+  Elf_Scn* split_section = elf_nextscn(elf, holed_section);
+  LOG_IF(FATAL, !split_section)
+      << "No section follows the section that contains the hole";
+  Elf_Scn* end_section = elf_nextscn(elf, last_section);
+  LOG_IF(FATAL, !end_section)
+      << "No section follows the last section in the segment being split";
+
+  // Split the first portion of split_header into spliced_header.  Done
+  // by copying the entire split_header into spliced_header, then changing
+  // only the fields that set the segment sizes.
+  *spliced_header = *split_header;
+  const ELF::Shdr* split_section_header = ELF::getshdr(split_section);
+  spliced_header->p_filesz = split_section_header->sh_offset;
+  spliced_header->p_memsz = split_section_header->sh_addr;
+
+  // Now rewrite split_header to remove the part we spliced from it.
+  const ELF::Shdr* end_section_header = ELF::getshdr(end_section);
+  split_header->p_offset = spliced_header->p_filesz;
+
+  CHECK(split_header->p_vaddr == split_header->p_paddr);
+  split_header->p_vaddr = spliced_header->p_memsz;
+  split_header->p_paddr = split_header->p_vaddr;
+
+  CHECK(split_header->p_filesz == split_header->p_memsz);
+  split_header->p_filesz =
+      end_section_header->sh_offset - spliced_header->p_filesz;
+  split_header->p_memsz = split_header->p_filesz;
+
+  // Adjust the offsets of all program headers that are not one of the pair
+  // we just created by splitting.
+  AdjustProgramHeaderOffsets(elf_program_header,
+                             program_header_count,
+                             spliced_header,
+                             split_header,
+                             hole_start,
+                             hole_size);
+
+  // Finally, order loadable segments by offset/address.  The crazy linker
+  // contains assumptions about loadable segment ordering.
+  SortOrderSensitiveProgramHeaders(elf_program_header,
+                                   program_header_count);
+}
+
+// Helper for ResizeSection().  Undo the work of SplitProgramHeadersForHole().
+void CoalesceProgramHeadersForHole(Elf* elf,
+                                   ELF::Off hole_start,
+                                   ssize_t hole_size) {
+  CHECK(hole_size > 0);
+  const ELF::Ehdr* elf_header = ELF::getehdr(elf);
+  CHECK(elf_header);
+
+  ELF::Phdr* elf_program_header = ELF::getphdr(elf);
+  CHECK(elf_program_header);
+
+  const size_t program_header_count = elf_header->e_phnum;
+
+  // Locate the segment that we overwrote to form the new LOAD entry, and
+  // the segment that we split into two parts on packing.
+  ELF::Phdr* spliced_header =
+      FindFirstLoadSegment(elf_program_header, program_header_count);
+  ELF::Phdr* split_header =
+      FindOriginalFirstLoadSegment(elf_program_header, program_header_count);
+
+  VLOG(1) << "phdr[" << spliced_header - elf_program_header << "] stack";
+  VLOG(1) << "phdr[" << split_header - elf_program_header << "] coalesce";
+
+  // Find the last section in the second segment we are coalescing.
+  Elf_Scn* last_section =
+      FindLastSectionInSegment(elf, split_header, hole_start, hole_size);
+
+  size_t string_index;
+  elf_getshdrstrndx(elf, &string_index);
+
+  const ELF::Shdr* section_header = ELF::getshdr(last_section);
+  std::string name = elf_strptr(elf, string_index, section_header->sh_name);
+  VLOG(1) << "section " << name << " coalesced";
+
+  // Rewrite the coalesced segment into split_header.
+  const ELF::Shdr* last_section_header = ELF::getshdr(last_section);
+  split_header->p_offset = spliced_header->p_offset;
+  split_header->p_vaddr = spliced_header->p_vaddr;
+  split_header->p_paddr = split_header->p_vaddr;
+  split_header->p_filesz =
+      last_section_header->sh_offset + last_section_header->sh_size;
+  split_header->p_memsz = split_header->p_filesz;
+
+  // Reconstruct the original GNU_STACK segment into spliced_header.
+  spliced_header->p_type = PT_GNU_STACK;
+  spliced_header->p_offset = 0;
+  spliced_header->p_vaddr = 0;
+  spliced_header->p_paddr = 0;
+  spliced_header->p_filesz = 0;
+  spliced_header->p_memsz = 0;
+  spliced_header->p_flags = PF_R | PF_W;
+  spliced_header->p_align = ELF::kGnuStackSegmentAlignment;
+
+  // Adjust the offsets of all program headers that are not one of the pair
+  // we just coalesced.
+  AdjustProgramHeaderOffsets(elf_program_header,
+                             program_header_count,
+                             spliced_header,
+                             split_header,
+                             hole_start,
+                             hole_size);
+
+  // Finally, order loadable segments by offset/address.  The crazy linker
+  // contains assumptions about loadable segment ordering.
+  SortOrderSensitiveProgramHeaders(elf_program_header,
+                                   program_header_count);
+}
+
+// Helper for ResizeSection().  Rewrite program headers.
+void RewriteProgramHeadersForHole(Elf* elf,
+                                  ELF::Off hole_start,
+                                  ssize_t hole_size) {
+  // If hole_size is negative then we are removing a piece of the file, and
+  // we want to split program headers so that we keep the same addresses
+  // for text and data.  If positive, then we are putting that piece of the
+  // file back in, so we coalesce the previously split program headers.
+  if (hole_size < 0)
+    SplitProgramHeadersForHole(elf, hole_start, hole_size);
+  else if (hole_size > 0)
+    CoalesceProgramHeadersForHole(elf, hole_start, hole_size);
+}
+
+// Helper for ResizeSection().  Locate and return the dynamic section.
+Elf_Scn* GetDynamicSection(Elf* elf) {
+  const ELF::Ehdr* elf_header = ELF::getehdr(elf);
+  CHECK(elf_header);
+
+  const ELF::Phdr* elf_program_header = ELF::getphdr(elf);
+  CHECK(elf_program_header);
+
+  // Find the program header that describes the dynamic section.
+  const ELF::Phdr* dynamic_program_header = NULL;
+  for (size_t i = 0; i < elf_header->e_phnum; ++i) {
+    const ELF::Phdr* program_header = &elf_program_header[i];
+
+    if (program_header->p_type == PT_DYNAMIC) {
+      dynamic_program_header = program_header;
+    }
+  }
+  CHECK(dynamic_program_header);
+
+  // Now find the section with the same offset as this program header.
+  Elf_Scn* dynamic_section = NULL;
+  Elf_Scn* section = NULL;
+  while ((section = elf_nextscn(elf, section)) != NULL) {
+    ELF::Shdr* section_header = ELF::getshdr(section);
+
+    if (section_header->sh_offset == dynamic_program_header->p_offset) {
+      dynamic_section = section;
+    }
+  }
+  CHECK(dynamic_section != NULL);
+
+  return dynamic_section;
 }
 
 // Helper for ResizeSection().  Adjust the .dynamic section for the hole.
 template <typename Rel>
 void AdjustDynamicSectionForHole(Elf_Scn* dynamic_section,
-                                 bool is_relocations_resize,
                                  ELF::Off hole_start,
                                  ssize_t hole_size) {
   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]));
 
   for (size_t i = 0; i < dynamics.size(); ++i) {
     ELF::Dyn* dynamic = &dynamics[i];
     const ELF::Sword tag = dynamic->d_tag;
-    // Any tags that hold offsets are adjustment candidates.
-    const bool is_adjustable = (tag == DT_PLTGOT ||
-                                tag == DT_HASH ||
-                                tag == DT_STRTAB ||
-                                tag == DT_SYMTAB ||
-                                tag == DT_RELA ||
-                                tag == DT_INIT ||
-                                tag == DT_FINI ||
-                                tag == DT_REL ||
-                                tag == DT_JMPREL ||
-                                tag == DT_INIT_ARRAY ||
-                                tag == DT_FINI_ARRAY ||
-                                tag == DT_ANDROID_REL_OFFSET);
-    if (is_adjustable && dynamic->d_un.d_ptr > hole_start) {
-      dynamic->d_un.d_ptr += hole_size;
-      VLOG(1) << "dynamic[" << i << "] " << dynamic->d_tag
-              << " d_ptr adjusted to " << dynamic->d_un.d_ptr;
-    }
-
-    // If we are specifically resizing dynamic relocations, we need to make
-    // some added adjustments to tags that indicate the counts of relative
-    // relocations in the shared object.
-    if (!is_relocations_resize)
-      continue;
 
     // DT_RELSZ or DT_RELASZ indicate the overall size of relocations.
     // Only one will be present.  Adjust by hole size.
     if (tag == DT_RELSZ || tag == DT_RELASZ) {
       dynamic->d_un.d_val += hole_size;
       VLOG(1) << "dynamic[" << i << "] " << dynamic->d_tag
               << " d_val adjusted to " << dynamic->d_un.d_val;
     }
 
     // DT_RELCOUNT or DT_RELACOUNT hold the count of relative relocations.
     // Only one will be present.  Packing reduces it to the alignment
     // padding, if any; unpacking restores it to its former value.  The
     // crazy linker does not use it, but we update it anyway.
     if (tag == DT_RELCOUNT || tag == DT_RELACOUNT) {
       // Cast sizeof to a signed type to avoid the division result being
       // promoted into an unsigned size_t.
       const ssize_t sizeof_rel = static_cast<ssize_t>(sizeof(Rel));
       dynamic->d_un.d_val += hole_size / sizeof_rel;
       VLOG(1) << "dynamic[" << i << "] " << dynamic->d_tag
               << " d_val adjusted to " << dynamic->d_un.d_val;
     }
 
-    // DT_RELENT and DT_RELAENT don't change, but make sure they are what
+    // 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);
 }
 
-// Helper for ResizeSection().  Adjust the .dynsym section for the hole.
-// We need to adjust the values for the symbols represented in it.
-void AdjustDynSymSectionForHole(Elf_Scn* dynsym_section,
-                                ELF::Off hole_start,
-                                ssize_t hole_size) {
-  Elf_Data* data = GetSectionData(dynsym_section);
-
-  const ELF::Sym* dynsym_base = reinterpret_cast<ELF::Sym*>(data->d_buf);
-  std::vector<ELF::Sym> dynsyms
-      (dynsym_base,
-       dynsym_base + data->d_size / sizeof(dynsyms[0]));
-
-  for (size_t i = 0; i < dynsyms.size(); ++i) {
-    ELF::Sym* dynsym = &dynsyms[i];
-    const int type = static_cast<int>(ELF_ST_TYPE(dynsym->st_info));
-    const bool is_adjustable = (type == STT_OBJECT ||
-                                type == STT_FUNC ||
-                                type == STT_SECTION ||
-                                type == STT_FILE ||
-                                type == STT_COMMON ||
-                                type == STT_TLS);
-    if (is_adjustable && dynsym->st_value > hole_start) {
-      dynsym->st_value += hole_size;
-      VLOG(1) << "dynsym[" << i << "] type=" << type
-              << " st_value adjusted to " << dynsym->st_value;
-    }
-  }
-
-  void* section_data = &dynsyms[0];
-  size_t bytes = dynsyms.size() * sizeof(dynsyms[0]);
-  RewriteSectionData(data, section_data, bytes);
-}
-
-// Helper for ResizeSection().  Adjust the plt relocations section for the
-// hole.  We need to adjust the offset of every relocation inside it that
-// falls beyond the hole start.
-template <typename Rel>
-void AdjustRelPltSectionForHole(Elf_Scn* relplt_section,
-                                ELF::Off hole_start,
-                                ssize_t hole_size) {
-  Elf_Data* data = GetSectionData(relplt_section);
-
-  const Rel* relplt_base = reinterpret_cast<Rel*>(data->d_buf);
-  std::vector<Rel> relplts(
-      relplt_base,
-      relplt_base + data->d_size / sizeof(relplts[0]));
-
-  for (size_t i = 0; i < relplts.size(); ++i) {
-    Rel* relplt = &relplts[i];
-    if (relplt->r_offset > hole_start) {
-      relplt->r_offset += hole_size;
-      VLOG(1) << "relplt[" << i
-              << "] r_offset adjusted to " << relplt->r_offset;
-    }
-  }
-
-  void* section_data = &relplts[0];
-  size_t bytes = relplts.size() * sizeof(relplts[0]);
-  RewriteSectionData(data, section_data, bytes);
-}
-
-// Helper for ResizeSection().  Adjust the .symtab section for the hole.
-// We want to adjust the value of every symbol in it that falls beyond
-// the hole start.
-void AdjustSymTabSectionForHole(Elf_Scn* symtab_section,
-                                ELF::Off hole_start,
-                                ssize_t hole_size) {
-  Elf_Data* data = GetSectionData(symtab_section);
-
-  const ELF::Sym* symtab_base = reinterpret_cast<ELF::Sym*>(data->d_buf);
-  std::vector<ELF::Sym> symtab(
-      symtab_base,
-      symtab_base + data->d_size / sizeof(symtab[0]));
-
-  for (size_t i = 0; i < symtab.size(); ++i) {
-    ELF::Sym* sym = &symtab[i];
-    if (sym->st_value > hole_start) {
-      sym->st_value += hole_size;
-      VLOG(1) << "symtab[" << i << "] value adjusted to " << sym->st_value;
-    }
-  }
-
-  void* section_data = &symtab[0];
-  size_t bytes = symtab.size() * sizeof(symtab[0]);
-  RewriteSectionData(data, 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;
 
-  // Note if we are resizing the real dyn relocations.  If yes, then we have
-  // to massage d_un.d_val in the dynamic section where d_tag is DT_RELSZ or
-  // DT_RELASZ and DT_RELCOUNT or DT_RELACOUNT.
+  // Note if we are resizing the real dyn relocations.
   size_t string_index;
   elf_getshdrstrndx(elf, &string_index);
   const std::string section_name =
       elf_strptr(elf, string_index, section_header->sh_name);
   const bool is_relocations_resize =
       (section_name == ".rel.dyn" || section_name == ".rela.dyn");
 
   // Require that the section size and the data size are the same.  True
   // in practice for all sections we resize when packing or unpacking.
   Elf_Data* data = GetSectionData(section);
   CHECK(data->d_off == 0 && data->d_size == section_header->sh_size);
 
   // Require that the section is not zero-length (that is, has allocated
   // data that we can validly expand).
   CHECK(data->d_size && data->d_buf);
 
   const ELF::Off hole_start = section_header->sh_offset;
   const ssize_t hole_size = new_size - data->d_size;
 
   VLOG_IF(1, (hole_size > 0)) << "expand section size = " << data->d_size;
   VLOG_IF(1, (hole_size < 0)) << "shrink section size = " << data->d_size;
 
   // Resize the data and the section header.
   data->d_size += hole_size;
   section_header->sh_size += hole_size;
 
-  ELF::Ehdr* elf_header = ELF::getehdr(elf);
-  ELF::Phdr* elf_program_header = ELF::getphdr(elf);
-
   // Add the hole size to all offsets in the ELF file that are after the
   // start of the hole.  If the hole size is positive we are expanding the
   // section to create a new hole; if negative, we are closing up a hole.
 
   // Start with the main ELF header.
+  ELF::Ehdr* elf_header = ELF::getehdr(elf);
   AdjustElfHeaderForHole(elf_header, hole_start, hole_size);
 
-  // Adjust all program headers.
-  AdjustProgramHeadersForHole(elf_program_header,
-                              elf_header->e_phnum,
-                              hole_start,
-                              hole_size);
-
   // Adjust all section headers.
   AdjustSectionHeadersForHole(elf, hole_start, hole_size);
 
-  // We use the dynamic program header entry to locate the dynamic section.
-  const ELF::Phdr* dynamic_program_header = NULL;
+  // If resizing the dynamic relocations, rewrite the program headers to
+  // either split or coalesce segments, and adjust dynamic entries to match.
+  if (is_relocations_resize) {
+    RewriteProgramHeadersForHole(elf, hole_start, hole_size);
 
-  // Find the dynamic program header entry.
-  for (size_t i = 0; i < elf_header->e_phnum; ++i) {
-    ELF::Phdr* program_header = &elf_program_header[i];
-
-    if (program_header->p_type == PT_DYNAMIC) {
-      dynamic_program_header = program_header;
-    }
+    Elf_Scn* dynamic_section = GetDynamicSection(elf);
+    AdjustDynamicSectionForHole<Rel>(dynamic_section, hole_start, hole_size);
   }
-  CHECK(dynamic_program_header);
-
-  // Sections requiring special attention, and the packed android
-  // relocations offset.
-  Elf_Scn* dynamic_section = NULL;
-  Elf_Scn* dynsym_section = NULL;
-  Elf_Scn* plt_relocations_section = NULL;
-  Elf_Scn* symtab_section = NULL;
-  ELF::Off android_relocations_offset = 0;
-
-  // Find these sections, and the packed android relocations offset.
-  section = NULL;
-  while ((section = elf_nextscn(elf, section)) != NULL) {
-    ELF::Shdr* section_header = ELF::getshdr(section);
-    std::string name = elf_strptr(elf, string_index, section_header->sh_name);
-
-    if (section_header->sh_offset == dynamic_program_header->p_offset) {
-      dynamic_section = section;
-    }
-    if (name == ".dynsym") {
-      dynsym_section = section;
-    }
-    if (name == ".rel.plt" || name == ".rela.plt") {
-      plt_relocations_section = section;
-    }
-    if (name == ".symtab") {
-      symtab_section = section;
-    }
-
-    // Note packed android relocations offset.
-    if (name == ".android.rel.dyn" || name == ".android.rela.dyn") {
-      android_relocations_offset = section_header->sh_offset;
-    }
-  }
-  CHECK(dynamic_section != NULL);
-  CHECK(dynsym_section != NULL);
-  CHECK(plt_relocations_section != NULL);
-  CHECK(android_relocations_offset != 0);
-
-  // Adjust the .dynamic section for the hole.  Because we have to edit the
-  // current contents of .dynamic we disallow resizing it.
-  CHECK(section != dynamic_section);
-  AdjustDynamicSectionForHole<Rel>(dynamic_section,
-                                   is_relocations_resize,
-                                   hole_start,
-                                   hole_size);
-
-  // Adjust the .dynsym section for the hole.
-  AdjustDynSymSectionForHole(dynsym_section, hole_start, hole_size);
-
-  // Adjust the plt relocations section for the hole.
-  AdjustRelPltSectionForHole<Rel>(plt_relocations_section,
-                                  hole_start,
-                                  hole_size);
-
-  // If present, adjust the .symtab section for the hole.  If the shared
-  // library was stripped then .symtab will be absent.
-  if (symtab_section)
-    AdjustSymTabSectionForHole(symtab_section, hole_start, hole_size);
 }
 
 // Find the first slot in a dynamics array with the given tag.  The array
 // always ends with a free (unused) element, and which we exclude from the
 // search.  Returns dynamics->size() if not found.
 size_t FindDynamicEntry(ELF::Sword tag,
                         std::vector<ELF::Dyn>* dynamics) {
   // Loop until the penultimate entry.  We exclude the end sentinel.
   for (size_t i = 0; i < dynamics->size() - 1; ++i) {
     if (dynamics->at(i).d_tag == tag)
@@ skipping 32 matching lines @@
   for (size_t i = slot; i < dynamics->size() - 1; ++i) {
     dynamics->at(i) = dynamics->at(i + 1);
     VLOG(1) << "dynamic[" << i
             << "] overwritten with dynamic[" << i + 1 << "]";
   }
 
   // Ensure that the end sentinel is still present.
   CHECK(dynamics->at(dynamics->size() - 1).d_tag == DT_NULL);
 }
 
-// Adjust a relocation.  For a relocation without addend, we find its target
-// in the section and adjust that.  For a relocation with addend, the target
-// is the relocation addend, and the section data at the target is zero.
-template <typename Rel>
-void AdjustRelocation(ssize_t index,
-                      ELF::Addr hole_start,
-                      ssize_t hole_size,
-                      Rel* relocation,
-                      ELF::Off* target);
-
-template <>
-void AdjustRelocation<ELF::Rel>(ssize_t index,
-                                ELF::Addr hole_start,
-                                ssize_t hole_size,
-                                ELF::Rel* relocation,
-                                ELF::Off* target) {
-  // Adjust the target if after the hole start.
-  if (*target > hole_start) {
-    *target += hole_size;
-    VLOG(1) << "relocation[" << index << "] target adjusted to " << *target;
-  }
-}
-
-template <>
-void AdjustRelocation<ELF::Rela>(ssize_t index,
-                                 ELF::Addr hole_start,
-                                 ssize_t hole_size,
-                                 ELF::Rela* relocation,
-                                 ELF::Off* target) {
-  // The relocation's target is the addend.  Adjust if after the hole start.
-  if (relocation->r_addend > hole_start) {
-    relocation->r_addend += hole_size;
-    VLOG(1) << "relocation["
-            << index << "] addend adjusted to " << relocation->r_addend;
-  }
-}
-
-// For relative relocations without addends, adjust the file data to which
-// they refer.  For relative relocations with addends, adjust the addends.
-// This translates data into the area it will occupy after the hole in
-// the dynamic relocations is added or removed.
-template <typename Rel>
-void AdjustRelocationTargets(Elf* elf,
-                             ELF::Off hole_start,
-                             ssize_t hole_size,
-                             std::vector<Rel>* relocations) {
-  Elf_Scn* section = NULL;
-  while ((section = elf_nextscn(elf, section)) != NULL) {
-    const ELF::Shdr* section_header = ELF::getshdr(section);
-
-    // Ignore sections that do not appear in a process memory image.
-    if (section_header->sh_addr == 0)
-      continue;
-
-    Elf_Data* data = GetSectionData(section);
-
-    // Ignore sections with no effective data.
-    if (data->d_buf == NULL)
-      continue;
-
-    // Identify this section's start and end addresses.
-    const ELF::Addr section_start = section_header->sh_addr;
-    const ELF::Addr section_end = section_start + section_header->sh_size;
-
-    // Create a copy of the section's data.
-    uint8_t* area = new uint8_t[data->d_size];
-    memcpy(area, data->d_buf, data->d_size);
-
-    for (size_t i = 0; i < relocations->size(); ++i) {
-      Rel* relocation = &relocations->at(i);
-      CHECK(ELF_R_TYPE(relocation->r_info) == ELF::kRelativeRelocationCode);
-
-      // See if this relocation points into the current section.
-      if (relocation->r_offset >= section_start &&
-          relocation->r_offset < section_end) {
-        // The relocation's target is what it points to in area.
-        // For relocations without addend, this is what we adjust; for
-        // relocations with addend, we leave this (it will be zero)
-        // and instead adjust the addend.
-        ELF::Addr byte_offset = relocation->r_offset - section_start;
-        ELF::Off* target = reinterpret_cast<ELF::Off*>(area + byte_offset);
-        AdjustRelocation<Rel>(i, hole_start, hole_size, relocation, target);
-      }
-    }
-
-    // If we altered the data for this section, write it back.
-    if (memcmp(area, data->d_buf, data->d_size)) {
-      RewriteSectionData(data, area, data->d_size);
-    }
-    delete [] area;
-  }
-}
-
-// Pad relocations with a given number of null relocations.
 template <typename Rel>
 void PadRelocations(size_t count, std::vector<Rel>* relocations);
 
 template <>
 void PadRelocations<ELF::Rel>(size_t count,
                               std::vector<ELF::Rel>* relocations) {
   ELF::Rel null_relocation;
   null_relocation.r_offset = 0;
   null_relocation.r_info = ELF_R_INFO(0, ELF::kNoRelocationCode);
   std::vector<ELF::Rel> padding(count, null_relocation);
   relocations->insert(relocations->end(), padding.begin(), padding.end());
 }
 
 template <>
 void PadRelocations<ELF::Rela>(size_t count,
                                std::vector<ELF::Rela>* relocations) {
   ELF::Rela null_relocation;
   null_relocation.r_offset = 0;
   null_relocation.r_info = ELF_R_INFO(0, ELF::kNoRelocationCode);
   null_relocation.r_addend = 0;
   std::vector<ELF::Rela> padding(count, null_relocation);
   relocations->insert(relocations->end(), padding.begin(), padding.end());
 }
 
-// Adjust relocations so that the offset that they indicate will be correct
-// after the hole in the dynamic relocations is added or removed (in effect,
-// relocate the relocations).
-template <typename Rel>
-void AdjustRelocations(ELF::Off hole_start,
-                       ssize_t hole_size,
-                       std::vector<Rel>* relocations) {
-  for (size_t i = 0; i < relocations->size(); ++i) {
-    Rel* relocation = &relocations->at(i);
-    if (relocation->r_offset > hole_start) {
-      relocation->r_offset += hole_size;
-      VLOG(1) << "relocation[" << i
-              << "] offset adjusted to " << relocation->r_offset;
-    }
-  }
-}
-
 }  // namespace
 
 // Remove relative entries from dynamic relocations and write as packed
 // data into android packed relocations.
 bool ElfFile::PackRelocations() {
   // Load the ELF file into libelf.
   if (!Load()) {
     LOG(ERROR) << "Failed to load as ELF";
     return false;
   }
@@ skipping 49 matching lines @@
   LOG(INFO) << "Other         : " << other_relocations.size() << " entries";
   LOG(INFO) << "Total         : " << relocations.size() << " entries";
 
   // If no relative relocations then we have nothing packable.  Perhaps
   // the shared object has already been packed?
   if (relative_relocations.empty()) {
     LOG(ERROR) << "No relative relocations found (already packed?)";
     return false;
   }
 
-  // Unless padding, pre-apply relative relocations to account for the
-  // hole, and pre-adjust all relocation offsets accordingly.
+  // If not padding fully, apply only enough padding to preserve alignment.
+  // Otherwise, pad so that we do not shrink the relocations section at all.
   if (!is_padding_relocations_) {
-    // Pre-calculate the size of the hole we will close up when we rewrite
-    // dynamic relocations.  We have to adjust relocation addresses to
-    // account for this.
+    // Calculate the size of the hole we will close up when we rewrite
+    // dynamic relocations.
     ELF::Shdr* section_header = ELF::getshdr(relocations_section_);
     const ELF::Off hole_start = section_header->sh_offset;
     ssize_t hole_size =
         relative_relocations.size() * sizeof(relative_relocations[0]);
     const ssize_t unaligned_hole_size = hole_size;
 
     // Adjust the actual hole size to preserve alignment.  We always adjust
     // by a whole number of NONE-type relocations.
     while (hole_size % kPreserveAlignment)
       hole_size -= sizeof(relative_relocations[0]);
@@ skipping 18 matching lines @@
 
     // Padding may have removed any packing benefit.
     if (padding >= relative_relocations.size()) {
       LOG(INFO) << "Too few relative relocations to pack after padding";
       return false;
     }
 
     // Add null relocations to other_relocations to preserve alignment.
     PadRelocations<Rel>(padding, &other_relocations);
     LOG(INFO) << "Alignment pad : " << padding << " relocations";
-
-    // Apply relocations to all relative data to relocate it into the
-    // area it will occupy once the hole in the dynamic relocations is removed.
-    AdjustRelocationTargets<Rel>(
-        elf_, hole_start, -hole_size, &relative_relocations);
-    // Relocate the relocations.
-    AdjustRelocations<Rel>(hole_start, -hole_size, &relative_relocations);
-    AdjustRelocations<Rel>(hole_start, -hole_size, &other_relocations);
   } else {
     // If padding, add NONE-type 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 padding = relocations.size() - other_relocations.size();
     PadRelocations<Rel>(padding, &other_relocations);
   }
 
   // Pack relative relocations.
   const size_t initial_bytes =
@@ skipping 42 matching lines @@
 
   // Rewrite .dynamic to include two new tags describing the 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]));
   // Use two of the spare slots to describe the packed section.
   ELF::Shdr* section_header = ELF::getshdr(android_relocations_section_);
-  const ELF::Dyn offset_dyn
-      = {DT_ANDROID_REL_OFFSET, {section_header->sh_offset}};
-  AddDynamicEntry(offset_dyn, &dynamics);
-  const ELF::Dyn size_dyn
-      = {DT_ANDROID_REL_SIZE, {section_header->sh_size}};
-  AddDynamicEntry(size_dyn, &dynamics);
+  {
+    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);
 
   Flush();
   return true;
 }
 
 // Find packed relative relocations in the packed android relocations
 // section, unpack them, and rewrite the dynamic relocations section to
@@ skipping 91 matching lines @@
     // dynamic relocations.  We have to adjust relocation addresses to
     // account for this.
     ELF::Shdr* section_header = ELF::getshdr(relocations_section_);
     const ELF::Off hole_start = section_header->sh_offset;
     ssize_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(INFO) << "Expansion     : " << hole_size << " bytes";
-
-    // Apply relocations to all relative data to relocate it into the
-    // area it will occupy once the hole in dynamic relocations is opened.
-    AdjustRelocationTargets<Rel>(
-        elf_, hole_start, hole_size, &relative_relocations);
-    // Relocate the relocations.
-    AdjustRelocations<Rel>(hole_start, hole_size, &relative_relocations);
-    AdjustRelocations<Rel>(hole_start, hole_size, &other_relocations);
   }
 
   // Rewrite the current dynamic relocations section to be the relative
   // 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];
@@ skipping 42 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