Support for unpacked ARM packed relocations.

third_party/android_crazy_linker/src/src/crazy_linker_elf_relocations.cpp

 // 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 "crazy_linker_elf_relocations.h"
 
 #include <errno.h>
 
 #include "crazy_linker_debug.h"
 #include "crazy_linker_elf_symbols.h"
 #include "crazy_linker_elf_view.h"
 #include "crazy_linker_error.h"
+#include "crazy_linker_system.h"
 #include "crazy_linker_util.h"
 #include "linker_phdr.h"
 
 #define DEBUG_RELOCATIONS 0
 
 #define RLOG(...) LOG_IF(DEBUG_RELOCATIONS, __VA_ARGS__)
 #define RLOG_ERRNO(...) LOG_ERRNO_IF(DEBUG_RELOCATIONS, __VA_ARGS__)
 
 #ifndef DF_SYMBOLIC
 #define DF_SYMBOLIC 2
@@ skipping 256 matching lines @@
                         error))
       return false;
     if (!ApplyRelRelocs(reinterpret_cast<ELF::Rel*>(relocations_),
                         relocations_size_ / sizeof(ELF::Rel),
                         symbols,
                         resolver,
                         error))
       return false;
   }
 
-  else if (relocations_type_ == DT_RELA) {
+  if (relocations_type_ == DT_RELA) {
     if (!ApplyRelaRelocs(reinterpret_cast<ELF::Rela*>(plt_relocations_),
                          plt_relocations_size_ / sizeof(ELF::Rela),
                          symbols,
                          resolver,
                          error))
       return false;
     if (!ApplyRelaRelocs(reinterpret_cast<ELF::Rela*>(relocations_),
                          relocations_size_ / sizeof(ELF::Rela),
                          symbols,
                          resolver,
                          error))
       return false;
   }
 
+#ifdef __arm__
+  if (!ApplyArmPackedRelocs(error))
+    return false;
+#endif
+
 #ifdef __mips__
   if (!RelocateMipsGot(symbols, resolver, error))
     return false;
 #endif
 
   if (has_text_relocations_) {
     if (phdr_table_protect_segments(phdr_, phdr_count_, load_bias_) < 0) {
       error->Format("Can't reprotect loadable segments: %s", strerror(errno));
       return false;
     }
   }
 
   LOG("%s: Done\n", __FUNCTION__);
   return true;
 }
 
+#ifdef __arm__
+
+void ElfRelocations::RegisterArmPackedRelocs(uint8_t* arm_packed_relocs) {
+  arm_packed_relocs_ = arm_packed_relocs;
+}
+
+// Helper class for decoding packed ARM relocation data.
+// http://en.wikipedia.org/wiki/LEB128
+class Leb128Decoder {
+ public:
+  explicit Leb128Decoder(const uint8_t* encoding)
+      : encoding_(encoding), cursor_(0) { }
+
+  uint32_t Dequeue() {
+    size_t extent = cursor_;
+    while (encoding_[extent] >> 7)
+      extent++;
+
+    uint32_t value = 0;
+    for (size_t i = extent; i > cursor_; --i) {
+      value = (value << 7) | (encoding_[i] & 127);
+    }
+    value = (value << 7) | (encoding_[cursor_] & 127);
+
+    cursor_ = extent + 1;
+    return value;
+  }
+
+ private:
+  const uint8_t* encoding_;
+  size_t cursor_;
+};
+
+bool ElfRelocations::ApplyArmPackedRelocs(Error* error) {
+  if (!arm_packed_relocs_)
+    return true;
+
+  Leb128Decoder decoder(arm_packed_relocs_);
+
+  // Check for the initial APR1 header.
+  if (decoder.Dequeue() != 'A' || decoder.Dequeue() != 'P' ||
+      decoder.Dequeue() != 'R' || decoder.Dequeue() != '1') {
+    error->Format("Bad packed relocations ident, expected APR1");
+    return false;
+  }
+
+  // Find the count of pairs and the start address.
+  size_t pairs = decoder.Dequeue();
+  const Elf32_Addr start_address = decoder.Dequeue();
+
+  // Emit initial R_ARM_RELATIVE relocation.
+  Elf32_Rel relocation = {start_address, R_ARM_RELATIVE};
+  const ELF::Addr sym_addr = 0;
+  const bool resolved = false;
+  if (!ApplyRelReloc(&relocation, sym_addr, resolved, error))
+    return false;
+
+  size_t unpacked_count = 1;
+
+  // Emit relocations for each count-delta pair.
+  while (pairs) {
+    size_t count = decoder.Dequeue();
+    const size_t delta = decoder.Dequeue();
+
+    // Emit count R_ARM_RELATIVE relocations with delta offset.
+    while (count) {
+      relocation.r_offset += delta;
+      if (!ApplyRelReloc(&relocation, sym_addr, resolved, error))
+        return false;
+      unpacked_count++;
+      count--;
+    }
+    pairs--;
+  }
+
+  RLOG("%s: unpacked_count=%d\n", __FUNCTION__, unpacked_count);
+  return true;
+}
+#endif  // __arm__
+
 bool ElfRelocations::ApplyRelaReloc(const ELF::Rela* rela,
                                     ELF::Addr sym_addr,
                                     bool resolved CRAZY_UNUSED,
                                     Error* error) {
   const ELF::Word rela_type = ELF_R_TYPE(rela->r_info);
   const ELF::Word CRAZY_UNUSED rela_symbol = ELF_R_SYM(rela->r_info);
   const ELF::Sword CRAZY_UNUSED addend = rela->r_addend;
 
   const ELF::Addr reloc = static_cast<ELF::Addr>(rela->r_offset + load_bias_);
 
@@ skipping 490 matching lines @@
       if (got_addr < src_addr || got_addr >= src_addr + size)
         continue;
       ELF::Addr* dst_ptr = reinterpret_cast<ELF::Addr*>(got_addr + dst_delta);
       *dst_ptr += map_delta;
     }
   }
 #endif
 }
 
 }  // namespace crazy