Extend relocation packing to cover arm64.

tools/relocation_packer/src/run_length_encoder.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 "run_length_encoder.h"
 
 #include <vector>
 
 #include "debug.h"
 #include "elf_traits.h"
 
 namespace relocation_packer {
 
 namespace {
 
 // Generate a vector of deltas between the r_offset fields of adjacent
-// ARM relative relocations.
+// relative relocations.
 void GetDeltas(const std::vector<ELF::Rel>& relocations,
                std::vector<ELF::Addr>* deltas) {
   CHECK(relocations.size() >= 2);
 
   for (size_t i = 0; i < relocations.size() - 1; ++i) {
-    const ELF::Addr first = relocations[i].r_offset;
-    const ELF::Addr second = relocations[i + 1].r_offset;
+    const ELF::Rel* first = &relocations[i];
+    CHECK(ELF_R_TYPE(first->r_info) == ELF::kRelativeRelocationCode);
+
+    const ELF::Rel* second = &relocations[i + 1];
+    CHECK(ELF_R_TYPE(second->r_info) == ELF::kRelativeRelocationCode);
+
     // Requires that offsets are 'strictly increasing'.  The packing
     // algorithm fails if this does not hold.
-    CHECK(second > first);
-    deltas->push_back(second - first);
+    CHECK(second->r_offset > first->r_offset);
+    deltas->push_back(second->r_offset - first->r_offset);
   }
 }
 
 // Condense a set of r_offset deltas into a run-length encoded packing.
 // Represented as count-delta pairs, where count is the run length and
 // delta the common difference between adjacent r_offsets.
 void Condense(const std::vector<ELF::Addr>& deltas,
               std::vector<ELF::Xword>* packed) {
   CHECK(!deltas.empty());
   size_t count = 0;
@@ skipping 46 matching lines @@
       relocation.r_offset = addr;
       relocation.r_info = ELF_R_INFO(0, ELF::kRelativeRelocationCode);
       relocations->push_back(relocation);
       count--;
     }
   }
 }
 
 }  // namespace
 
-// Encode ARM relative relocations into a run-length encoded (packed)
+// Encode relative relocations into a run-length encoded (packed)
 // representation.
 void RelocationRunLengthCodec::Encode(const std::vector<ELF::Rel>& relocations,
                                       std::vector<ELF::Xword>* packed) {
   // If we have zero or one relocation only then there is no packing
   // possible; a run-length encoding needs a run.
   if (relocations.size() < 2)
     return;
 
   std::vector<ELF::Addr> deltas;
   GetDeltas(relocations, &deltas);
 
   // Reserve space for the element count.
   packed->push_back(0);
 
   // Initialize the packed data with the first offset, then follow up with
   // the condensed deltas vector.
   packed->push_back(relocations[0].r_offset);
   Condense(deltas, packed);
 
   // Fill in the packed pair count.
   packed->at(0) = (packed->size() - 2) >> 1;
 }
 
-// Decode ARM relative relocations from a run-length encoded (packed)
+// Decode relative relocations from a run-length encoded (packed)
 // representation.
 void RelocationRunLengthCodec::Decode(const std::vector<ELF::Xword>& packed,
                                       std::vector<ELF::Rel>* relocations) {
   // We need at least one packed pair after the packed pair count and start
   // address to be able to unpack.
   if (packed.size() < 4)
     return;
 
   // Ensure that the packed data offers enough pairs.  There may be zero
   // padding on it that we ignore.
   CHECK(packed[0] <= (packed.size() - 2) >> 1);
 
   // The first packed vector element is the pairs count and the second the
   // initial address.  Start uncondensing pairs at the third, and finish
   // at the end of the pairs data.
   const size_t pairs_count = packed[0];
   const ELF::Addr addr = packed[1];
   Uncondense(addr, packed, 2, 2 + (pairs_count << 1), relocations);
 }
 
 }  // namespace relocation_packer