Synchronize Android relocation packer source with AOSP.

third_party/android_platform/bionic/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 avoid fixing DWARF cfi data and relative relocation addresses.
 // So after packing we shift offets and starting address of the RX segment
 // while preserving code/data vaddrs location.
@@ skipping 172 matching lines @@
   // Notes of the dynamic relocations, packed relocations, and .dynamic
   // sections.  Found while iterating sections, and later stored in class
   // attributes.
   Elf_Scn* found_relocations_section = nullptr;
   Elf_Scn* found_dynamic_section = nullptr;
 
   // 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;
+  bool has_android_relocations = false;
 
   Elf_Scn* section = NULL;
   while ((section = elf_nextscn(elf, section)) != nullptr) {
     auto 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 || section_header->sh_type == SHT_ANDROID_REL) {
       has_rel_relocations = true;
     }
     if (section_header->sh_type == SHT_RELA || section_header->sh_type == SHT_ANDROID_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;
+
+      // Note if relocation section is already packed
+      has_android_relocations =
+          section_header->sh_type == SHT_ANDROID_REL ||
+          section_header->sh_type == SHT_ANDROID_RELA;
     }
 
     if (section_header->sh_offset == dynamic_program_header->p_offset) {
       found_dynamic_section = section;
     }
 
     // Ensure we preserve alignment, repeated later for the data block(s).
     CHECK(section_header->sh_addralign <= kPreserveAlignment);
 
     Elf_Data* data = NULL;
@@ skipping 21 matching lines @@
   if (has_rel_relocations && has_rela_relocations) {
     LOG(ERROR) << "Multiple relocations sections with different types found, "
                << "not currently supported";
     return false;
   }
 
   elf_ = elf;
   relocations_section_ = found_relocations_section;
   dynamic_section_ = found_dynamic_section;
   relocations_type_ = has_rel_relocations ? REL : RELA;
+  has_android_relocations_ = has_android_relocations;
   return true;
 }
 
 // Helper for ResizeSection().  Adjust the main ELF header for the hole.
 template <typename ELF>
 static void AdjustElfHeaderForHole(typename ELF::Ehdr* elf_header,
                                    typename ELF::Off hole_start,
                                    ssize_t hole_size) {
   if (elf_header->e_phoff > hole_start) {
     elf_header->e_phoff += hole_size;
@@ skipping 169 matching lines @@
                                 tag == DT_GNU_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_VERSYM ||
+                                tag == DT_VERNEED ||
+                                tag == DT_VERDEF ||
                                 tag == DT_ANDROID_REL||
                                 tag == DT_ANDROID_RELA);
 
     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;
     }
 
     // DT_RELSZ or DT_RELASZ indicate the overall size of relocations.
@@ skipping 127 matching lines @@
   // Retrieve the current dynamic relocations section data.
   Elf_Data* data = GetSectionData(relocations_section_);
   // we always pack rela, because packed format is pretty much the same
   std::vector<typename ELF::Rela> relocations;
 
   if (relocations_type_ == REL) {
     // Convert data to a vector of relocations.
     const typename ELF::Rel* relocations_base = reinterpret_cast<typename ELF::Rel*>(data->d_buf);
     ConvertRelArrayToRelaVector(relocations_base,
         data->d_size / sizeof(typename ELF::Rel), &relocations);
-    LOG(INFO) << "Relocations   : REL";
+    VLOG(1) << "Relocations   : REL";
   } else if (relocations_type_ == RELA) {
     // Convert data to a vector of relocations with addends.
     const typename ELF::Rela* relocations_base = reinterpret_cast<typename ELF::Rela*>(data->d_buf);
     relocations = std::vector<typename ELF::Rela>(
         relocations_base,
         relocations_base + data->d_size / sizeof(relocations[0]));
 
-    LOG(INFO) << "Relocations   : RELA";
+    VLOG(1) << "Relocations   : RELA";
   } else {
     NOTREACHED();
   }
 
   return PackTypedRelocations(&relocations);
 }
 
 // Helper for PackRelocations().  Rel type is one of ELF::Rel or ELF::Rela.
 template <typename ELF>
 bool ElfFile<ELF>::PackTypedRelocations(std::vector<typename ELF::Rela>* relocations) {
   typedef typename ELF::Rela Rela;
 
+  if (has_android_relocations_) {
+    LOG(ERROR) << "Relocation table is already packed";
+    return false;
+  }
+
   // If no relocations then we have nothing packable.  Perhaps
   // the shared object has already been packed?
   if (relocations->empty()) {
-    LOG(ERROR) << "No relocations found (already packed?)";
+    LOG(ERROR) << "No relocations found";
     return false;
   }
 
   const size_t rel_size =
       relocations_type_ == RELA ? sizeof(typename ELF::Rela) : sizeof(typename ELF::Rel);
   const size_t initial_bytes = relocations->size() * rel_size;
 
-  LOG(INFO) << "Unpacked                   : " << initial_bytes << " bytes";
+  VLOG(1) << "Unpacked                   : " << initial_bytes << " bytes";
   std::vector<uint8_t> packed;
   RelocationPacker<ELF> packer;
 
   // Pack relocations: dry run to estimate memory savings.
   packer.PackRelocations(*relocations, &packed);
   const size_t packed_bytes_estimate = packed.size() * sizeof(packed[0]);
-  LOG(INFO) << "Packed         (no padding): " << packed_bytes_estimate << " bytes";
+  VLOG(1) << "Packed         (no padding): " << packed_bytes_estimate << " bytes";
 
   if (packed.empty()) {
     LOG(INFO) << "Too few relocations to pack";
-    return false;
+    return true;
   }
 
   // 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.
   typename ELF::Shdr* section_header = ELF::getshdr(relocations_section_);
   ssize_t hole_size = initial_bytes - packed_bytes_estimate;
 
   // hole_size needs to be page_aligned.
   hole_size -= hole_size % kPreserveAlignment;
 
   LOG(INFO) << "Compaction                 : " << hole_size << " bytes";
 
   // Adjusting for alignment may have removed any packing benefit.
   if (hole_size == 0) {
     LOG(INFO) << "Too few relocations to pack after alignment";
-    return false;
+    return true;
   }
 
   if (hole_size <= 0) {
     LOG(INFO) << "Packing relocations saves no space";
-    return false;
+    return true;
   }
 
   size_t data_padding_bytes = is_padding_relocations_ ?
       initial_bytes - packed_bytes_estimate :
       initial_bytes - hole_size - packed_bytes_estimate;
 
   // pad data
   std::vector<uint8_t> padding(data_padding_bytes, 0);
   packed.insert(packed.end(), padding.begin(), padding.end());
 
@@ skipping 62 matching lines @@
   // Convert data to a vector of bytes.
   const uint8_t* packed_base = reinterpret_cast<uint8_t*>(data->d_buf);
   std::vector<uint8_t> packed(
       packed_base,
       packed_base + data->d_size / sizeof(packed[0]));
 
   if ((section_header->sh_type == SHT_ANDROID_RELA || section_header->sh_type == SHT_ANDROID_REL) &&
       packed.size() > 3 &&
       packed[0] == 'A' &&
       packed[1] == 'P' &&
-      (packed[2] == 'U' || packed[2] == 'S') &&
+      packed[2] == 'S' &&
       packed[3] == '2') {
     LOG(INFO) << "Relocations   : " << (relocations_type_ == REL ? "REL" : "RELA");
   } else {
     LOG(ERROR) << "Packed relocations not found (not packed?)";
     return false;
   }
 
   return UnpackTypedRelocations(packed);
 }
 
@@ skipping 125 matching lines @@
     rel.r_info = rela.r_info;
     CHECK(rela.r_addend == 0);
     rel_vector->push_back(rel);
   }
 }
 
 template class ElfFile<ELF32_traits>;
 template class ElfFile<ELF64_traits>;
 
 }  // namespace relocation_packer