Update from https://crrev.com/316786

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 38 matching lines @@
 // android packed relocations section.
 static const ELF::Sword DT_ANDROID_REL_OFFSET = DT_LOOS;
 static const ELF::Sword DT_ANDROID_REL_SIZE = DT_LOOS + 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.
 // Out of caution for RELRO page alignment, we preserve to a complete target
 // page.  See http://www.airs.com/blog/archives/189.
 static const size_t kPreserveAlignment = 4096;
 
+// Alignment values used by ld and gold for the GNU_STACK segment.  Different
+// linkers write different values; the actual value is immaterial on Android
+// because it ignores GNU_STACK segments.  However, it is useful for binary
+// comparison and unit test purposes if packing and unpacking can preserve
+// them through a round-trip.
+static const size_t kLdGnuStackSegmentAlignment = 16;
+static const size_t kGoldGnuStackSegmentAlignment = 0;
+
 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 287 matching lines @@
         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().  Deduce the alignment that the PT_GNU_STACK
+// segment will use.  Determined by sensing the linker that was used to
+// create the shared library.
+size_t DeduceGnuStackSegmentAlignment(Elf* elf) {
+  size_t string_index;
+  elf_getshdrstrndx(elf, &string_index);
+
+  Elf_Scn* section = NULL;
+  size_t gnu_stack_segment_alignment = kLdGnuStackSegmentAlignment;
+
+  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);
+
+    if (name == ".note.gnu.gold-version") {
+      gnu_stack_segment_alignment = kGoldGnuStackSegmentAlignment;
+      break;
+    }
+  }
+
+  return gnu_stack_segment_alignment;
+}
+
 // 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,
+ELF::Phdr* FindUnusedGnuStackSegment(Elf* elf,
+                                     ELF::Phdr* program_headers,
                                      size_t count) {
   ELF::Phdr* unused_segment = NULL;
+  const size_t stack_alignment = DeduceGnuStackSegmentAlignment(elf);
 
   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) {
+        program_header->p_align == stack_alignment) {
       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
@@ skipping 158 matching lines @@
   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);
+      FindUnusedGnuStackSegment(elf, 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);
@@ skipping 101 matching lines @@
   CHECK(split_header->p_vaddr == split_header->p_paddr);
   split_header->p_vaddr = spliced_header->p_vaddr;
   split_header->p_paddr = spliced_header->p_vaddr;
   CHECK(split_header->p_filesz == split_header->p_memsz);
   split_header->p_filesz =
       last_section_header->sh_offset + last_section_header->sh_size;
   split_header->p_memsz =
       last_section_header->sh_offset + last_section_header->sh_size;
 
   // Reconstruct the original GNU_STACK segment into spliced_header.
+  const size_t stack_alignment = DeduceGnuStackSegmentAlignment(elf);
   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;
+  spliced_header->p_align = stack_alignment;
 
   // 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);
 
@@ skipping 573 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