Set spliced LOAD segment's memsz equal to filesz.

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 515 matching lines @@
 //   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      0x000000  0x00000000 0x00000000 0x14ea4   0x14ea4   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,
@@ skipping 39 matching lines @@
 
   // 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;
+  // Split the first portion of split_header into spliced_header.
   const ELF::Shdr* split_section_header = ELF::getshdr(split_section);
+  spliced_header->p_type = split_header->p_type;
+  spliced_header->p_offset = split_header->p_offset;
+  spliced_header->p_vaddr = split_header->p_vaddr;
+  spliced_header->p_paddr = split_header->p_paddr;
+  CHECK(split_header->p_filesz == split_header->p_memsz);
   spliced_header->p_filesz = split_section_header->sh_offset;
-  spliced_header->p_memsz = split_section_header->sh_addr;
+  spliced_header->p_memsz = split_section_header->sh_offset;
+  spliced_header->p_flags = split_header->p_flags;
+  spliced_header->p_align = split_header->p_align;
 
   // 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;
-
+  split_header->p_vaddr = split_section_header->sh_addr;
+  split_header->p_paddr = split_section_header->sh_addr;
   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;
+  split_header->p_memsz =
+      end_section_header->sh_offset - spliced_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);
 
@@ skipping 33 matching lines @@
   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;
+  CHECK(split_header->p_vaddr == split_header->p_paddr);
   split_header->p_vaddr = spliced_header->p_vaddr;
-  split_header->p_paddr = split_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 = split_header->p_filesz;
+  split_header->p_memsz =
+      last_section_header->sh_offset + last_section_header->sh_size;
 
   // 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;
@@ skipping 593 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