Update DT_RELA* fields when packing relocations with addends.

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.
 
 #include "elf_file.h"
 
 #include <stdlib.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <string>
@@ skipping 374 matching lines @@
       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 is the overall size of relocations.  Adjust by hole size.
-    if (tag == DT_RELSZ) {
+    // DT_RELSZ or DT_RELASZ indicate the overall size of relocations.
+    // Only one will be present.  Adjust by hole size.

[rmcilroy, 2014/08/15 16:28:47]

Should we assert that only one is present?

+    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 is the count of relative relocations.  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) {
+    // 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 doesn't change, but make sure it is what we expect.
-    if (tag == DT_RELENT) {
+    // DT_RELENT and DT_RELAENT don't 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.
@@ skipping 86 matching lines @@
 // 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 and
-  // DT_RELCOUNT.
+  // 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.
   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);
@@ skipping 541 matching lines @@
   std::vector<Rel> relative_relocations;
   RelocationPacker packer;
   packer.UnpackRelativeRelocations(packed, &relative_relocations);
   const size_t unpacked_bytes =
       relative_relocations.size() * sizeof(relative_relocations[0]);
   LOG(INFO) << "Unpacked relative: " << unpacked_bytes << " bytes";
 
   // Retrieve the current dynamic relocations section data.
   data = GetSectionData(relocations_section_);
 
-  // Interpret data as Elf32 relocations.
+  // Interpret data as relocations.
   const Rel* relocations_base = reinterpret_cast<Rel*>(data->d_buf);
   std::vector<Rel> relocations(
       relocations_base,
       relocations_base + data->d_size / sizeof(relocations[0]));
 
   std::vector<Rel> other_relocations;
   size_t padding = 0;
 
   // Filter relocations to locate any that are NONE-type.  These will occur
   // if padding was turned on for packing.
@@ skipping 90 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