crazy linker: convert relocation unpacking to Android style.

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 <assert.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_leb128.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
 #endif
 
 #ifndef DF_TEXTREL
 #define DF_TEXTREL 4
 #endif
 
 #ifndef DT_FLAGS
 #define DT_FLAGS 30
 #endif
 
+// Extension dynamic tags for Android packed relocations.
+#ifndef DT_LOOS
+#define DT_LOOS 0x6000000d
+#endif
+#ifndef DT_ANDROID_REL
+#define DT_ANDROID_REL (DT_LOOS + 2)
+#endif
+#ifndef DT_ANDROID_RELSZ
+#define DT_ANDROID_RELSZ (DT_LOOS + 3)
+#endif
+#ifndef DT_ANDROID_RELA
+#define DT_ANDROID_RELA (DT_LOOS + 4)
+#endif
+#ifndef DT_ANDROID_RELASZ
+#define DT_ANDROID_RELASZ (DT_LOOS + 5)
+#endif
+
 // Processor-specific relocation types supported by the linker.
 #ifdef __arm__
 
 /* arm32 relocations */
 #define R_ARM_ABS32 2
 #define R_ARM_REL32 3
 #define R_ARM_GLOB_DAT 21
 #define R_ARM_JUMP_SLOT 22
 #define R_ARM_COPY 20
 #define R_ARM_RELATIVE 23
@@ skipping 176 matching lines @@
         if (relocations_size_) {
           *error = "Unsupported DT_RELASZ/DT_RELSZ combination in dyn section";
           return false;
         }
         relocations_size_ = dyn_value;
         if (tag == DT_RELASZ)
           has_rela_relocations = true;
         else
           has_rel_relocations = true;
         break;
+      case DT_ANDROID_RELA:
+      case DT_ANDROID_REL:
+        RLOG("  %s addr=%p\n",
+             (tag == DT_ANDROID_RELA) ? "DT_ANDROID_RELA" : "DT_ANDROID_REL",
+             dyn_addr);
+        if (android_relocations_) {
+          *error = "Unsupported DT_ANDROID_RELA/DT_ANDROID_REL "
+                   "combination in dynamic section";
+          return false;
+        }
+        android_relocations_ = reinterpret_cast<uint8_t*>(dyn_addr);
+        if (tag == DT_ANDROID_RELA)
+          has_rela_relocations = true;
+        else
+          has_rel_relocations = true;
+        break;
+      case DT_ANDROID_RELASZ:
+      case DT_ANDROID_RELSZ:
+        RLOG("  %s size=%d\n",
+             (tag == DT_ANDROID_RELASZ)
+                 ? "DT_ANDROID_RELASZ" : "DT_ANDROID_RELSZ", dyn_addr);
+        if (android_relocations_size_) {
+          *error = "Unsupported DT_ANDROID_RELASZ/DT_ANDROID_RELSZ "
+                   "combination in dyn section";
+          return false;
+        }
+        android_relocations_size_ = dyn_value;
+        if (tag == DT_ANDROID_RELASZ)
+          has_rela_relocations = true;
+        else
+          has_rel_relocations = true;
+        break;
       case DT_PLTGOT:
         // Only used on MIPS currently. Could also be used on other platforms
         // when lazy binding (i.e. RTLD_LAZY) is implemented.
         RLOG("  DT_PLTGOT addr=%p\n", dyn_addr);
         plt_got_ = reinterpret_cast<ELF::Addr*>(dyn_addr);
         break;
       case DT_TEXTREL:
         RLOG("  DT_TEXTREL\n");
         has_text_relocations_ = true;
         break;
       case DT_SYMBOLIC:
         RLOG("  DT_SYMBOLIC\n");
         has_symbolic_ = true;
         break;
       case DT_FLAGS:
         if (dyn_value & DF_TEXTREL)
           has_text_relocations_ = true;
         if (dyn_value & DF_SYMBOLIC)
           has_symbolic_ = true;
-        RLOG(" DT_FLAGS has_text_relocations=%s has_symbolic=%s\n",
+        RLOG("  DT_FLAGS has_text_relocations=%s has_symbolic=%s\n",
              has_text_relocations_ ? "true" : "false",
              has_symbolic_ ? "true" : "false");
         break;
 #if defined(__mips__)
       case DT_MIPS_SYMTABNO:
         RLOG("  DT_MIPS_SYMTABNO value=%d\n", dyn_value);
         mips_symtab_count_ = dyn_value;
         break;
 
       case DT_MIPS_LOCAL_GOTNO:
         RLOG("  DT_MIPS_LOCAL_GOTNO value=%d\n", dyn_value);
         mips_local_got_count_ = dyn_value;
         break;
 
       case DT_MIPS_GOTSYM:
         RLOG("  DT_MIPS_GOTSYM value=%d\n", dyn_value);
         mips_gotsym_ = dyn_value;
         break;
 #endif
       default:
         ;
     }
   }
 
   if (has_rel_relocations && has_rela_relocations) {
-    *error = "Combining DT_REL and DT_RELA is not currently supported";
+    *error = "Combining relocations with and without addends is not "
+             "currently supported";
     return false;
   }
 
   // If DT_PLTREL did not explicitly assign relocations_type_, set it
   // here based on the type of relocations found.
   if (relocations_type_ != DT_REL && relocations_type_ != DT_RELA) {
     if (has_rel_relocations)
       relocations_type_ = DT_REL;
     else if (has_rela_relocations)
       relocations_type_ = DT_RELA;
   }
 
   if (relocations_type_ == DT_REL && has_rela_relocations) {
-    *error = "Found DT_RELA in dyn section, but DT_PLTREL is DT_REL";
+    *error = "Found relocations with addends in dyn section, "
+             "but DT_PLTREL is DT_REL";
     return false;
   }
   if (relocations_type_ == DT_RELA && has_rel_relocations) {
-    *error = "Found DT_REL in dyn section, but DT_PLTREL is DT_RELA";
+    *error = "Found relocations without addends in dyn section, "
+             "but DT_PLTREL is DT_RELA";
     return false;
   }
 
   return true;
 }
 
 bool ElfRelocations::ApplyAll(const ElfSymbols* symbols,
                               SymbolResolver* resolver,
                               Error* error) {
   LOG("%s: Enter\n", __FUNCTION__);
 
   if (has_text_relocations_) {
     if (phdr_table_unprotect_segments(phdr_, phdr_count_, load_bias_) < 0) {
       error->Format("Can't unprotect loadable segments: %s", strerror(errno));
       return false;
     }
   }
 
-#if defined(__arm__) || defined(__aarch64__)
-  if (!ApplyPackedRelocations(error))
+  if (!ApplyAndroidRelocations(symbols, resolver, error))
     return false;
-#endif
 
   if (relocations_type_ == DT_REL) {
     if (!ApplyRelRelocs(reinterpret_cast<ELF::Rel*>(relocations_),
                         relocations_size_ / sizeof(ELF::Rel),
                         symbols,
                         resolver,
                         error))
       return false;
     if (!ApplyRelRelocs(reinterpret_cast<ELF::Rel*>(plt_relocations_),
                         plt_relocations_size_ / sizeof(ELF::Rel),
@@ skipping 27 matching lines @@
     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;
 }
 
-#if defined(__arm__) || defined(__aarch64__)
+// Helper class for Android packed relocations.  Encapsulates the packing
+// flags used by Android for packed relocation groups.
+class AndroidPackedRelocationGroupFlags {
+ public:
+  explicit AndroidPackedRelocationGroupFlags(size_t flags) : flags_(flags) { }
 
-void ElfRelocations::RegisterPackedRelocations(uint8_t* packed_relocations) {
-  packed_relocations_ = packed_relocations;
-}
-
-bool ElfRelocations::ApplyPackedRel(const uint8_t* packed_relocations,
-                                    Error* error) {
-  Leb128Decoder decoder(packed_relocations);
-
-  // Find the count of pairs and the start address.
-  size_t pairs = decoder.Dequeue();
-  const ELF::Addr start_address = decoder.Dequeue();
-
-  // Emit initial relative relocation.
-  ELF::Rel relocation;
-  relocation.r_offset = start_address;
-  relocation.r_info = ELF_R_INFO(0, RELATIVE_RELOCATION_CODE);
-  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 relative relocations with delta offset.
-    while (count) {
-      relocation.r_offset += delta;
-      if (!ApplyRelReloc(&relocation, sym_addr, resolved, error))
-        return false;
-      unpacked_count++;
-      count--;
-    }
-    pairs--;
+  bool is_relocation_grouped_by_info() const {
+    return hasFlag(RELOCATION_GROUPED_BY_INFO_FLAG);
+  }
+  bool is_relocation_grouped_by_offset_delta() const {
+    return hasFlag(RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG);
+  }
+  bool is_relocation_grouped_by_addend() const {
+    return hasFlag(RELOCATION_GROUPED_BY_ADDEND_FLAG);
+  }
+  bool is_relocation_group_has_addend() const {
+    return hasFlag(RELOCATION_GROUP_HAS_ADDEND_FLAG);
   }
 
-  RLOG("%s: unpacked_count=%d\n", __FUNCTION__, unpacked_count);
+ private:
+  bool hasFlag(size_t flag) const { return (flags_ & flag) != 0; }
+
+  static const size_t RELOCATION_GROUPED_BY_INFO_FLAG = 1 << 0;
+  static const size_t RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG = 1 << 1;
+  static const size_t RELOCATION_GROUPED_BY_ADDEND_FLAG = 1 << 2;
+  static const size_t RELOCATION_GROUP_HAS_ADDEND_FLAG = 1 << 3;
+
+  const size_t flags_;
+};
+
+bool ElfRelocations::ForEachAndroidRelocation(RelocationHandler handler,
+                                              void* opaque) {
+  // Skip over the "APU2" or "APS2" signature.
+  const uint8_t* data_start = android_relocations_ + 4;
+  const size_t data_size = android_relocations_size_ - 4;
+
+  // Create the appropriate type of LEB128 decoder, and wrap it inside a
+  // ScopedPtr for convenience.
+  Leb128Decoder* decoder;
+  if (android_relocations_[2] == 'U')
+    decoder = new Uleb128Decoder(data_start, data_size);
+  else
+    decoder = new Sleb128Decoder(data_start, data_size);

[rmcilroy, 2015/04/13 10:36:10]

nit - add a DCHECK that android_relocations_[2] == 'S'

[simonb (inactive), 2015/04/28 14:39:41]

Gone -- the android packer no longer generates unsigned LEB128 packing.
https://codereview.chromium.org/1099343004/

+  ScopedPtr<Leb128Decoder> scoped_decoder(decoder);
+
+  // Unpacking into a relocation with addend, both for REL and RELA, is
+  // convenient at this point. If REL, the handler needs to take care of
+  // any conversion before use.
+  ELF::Rela relocation;
+  memset(&relocation, 0, sizeof(relocation));
+
+  // Read the relocation count and initial offset.
+  const size_t relocation_count = decoder->pop_front();
+  relocation.r_offset = decoder->pop_front();
+
+  LOG("%s: relocation_count=%d, initial r_offset=%p\n",
+      __FUNCTION__,
+      relocation_count,
+      relocation.r_offset);
+
+  size_t relocations_handled = 0;
+  while (relocations_handled < relocation_count) {
+    // Read the start of the group header to obtain its size and flags.
+    const size_t group_size = decoder->pop_front();
+    AndroidPackedRelocationGroupFlags group_flags(decoder->pop_front());

[rmcilroy, 2015/04/13 10:36:10]

Maybe we could just package up the different group types to an object, which
get's passed the decoder and pulls out the size, flags and any optional header
fields and creates an appropriate AndroidRelocationGroup object based on these?

[simonb (inactive), 2015/04/28 14:39:41]

I'd like to keep this code close to that of the android relocation packer, so
that it is easier to visually check for correctness.
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/androi...

[rmcilroy, 2015/05/01 14:15:22]

Ok, SGTM.

+
+    // Read other group header fields, depending on the flags read above.
+    size_t group_r_offset_delta = 0;
+    if (group_flags.is_relocation_grouped_by_offset_delta())
+      group_r_offset_delta = decoder->pop_front();
+
+    if (group_flags.is_relocation_grouped_by_info())
+      relocation.r_info = decoder->pop_front();
+
+    if (group_flags.is_relocation_group_has_addend() &&
+        group_flags.is_relocation_grouped_by_addend())
+      relocation.r_addend += decoder->pop_front();
+    else if (!group_flags.is_relocation_group_has_addend())
+      relocation.r_addend = 0;
+
+    // Expand the group into individual relocations.
+    for (size_t group_index = 0; group_index < group_size; group_index++) {
+      if (group_flags.is_relocation_grouped_by_offset_delta())
+        relocation.r_offset += group_r_offset_delta;
+      else
+        relocation.r_offset += decoder->pop_front();
+
+      if (!group_flags.is_relocation_grouped_by_info())
+        relocation.r_info = decoder->pop_front();
+
+      if (group_flags.is_relocation_group_has_addend() &&
+          !group_flags.is_relocation_grouped_by_addend())
+        relocation.r_addend += decoder->pop_front();

[rmcilroy, 2015/04/13 10:36:10]

If you do the suggestion above then the AndroidRelocationGroup could have a
method which process each relocation based on the appropriate flags, WDYT?

[simonb (inactive), 2015/04/28 14:39:41]

Acknowledged.

+
+      // Pass the relocation to the supplied handler function. If the handler
+      // returns false we view this as failure and return false to our caller.
+      if (!handler(this, &relocation, opaque)) {
+        LOG("%s: failed handling relocation %d\n",
+            __FUNCTION__,
+            relocations_handled);
+        return false;
+      }
+
+      relocations_handled++;
+    }
+  }
+
+  LOG("%s: relocations_handled=%d\n", __FUNCTION__, relocations_handled);
   return true;
 }
 
-bool ElfRelocations::ApplyPackedRela(const uint8_t* packed_relocations,
-                                     Error* error) {
-  Sleb128Decoder decoder(packed_relocations);
+namespace {

[rmcilroy, 2015/04/13 10:36:10]

Could we just make these private static functions instead of static functions in
an anonymous namespace?

[simonb (inactive), 2015/04/28 14:39:41]

We could.  Not sure what it would buy us though.

[rmcilroy, 2015/05/01 14:15:21]

It just seems strange to have a mix of private functions and anonymous namespace
ones, but I don't really mind this is fine.

 
-  // Find the count of pairs.
-  size_t pairs = decoder.Dequeue();
+// Validate the Android packed relocations signature.
+bool IsValidAndroidPackedRelocations(const uint8_t* android_relocations,
+                                     size_t android_relocations_size) {
+  if (android_relocations_size < 4)
+    return false;
 
-  ELF::Addr offset = 0;
-  ELF::Sxword addend = 0;
+  // Check for an initial APU2 or APS2 Android packed relocations header.
+  return (android_relocations[0] == 'A' &&
+          android_relocations[1] == 'P' &&
+          (android_relocations[2] == 'U' || android_relocations[2] == 'S') &&
+          android_relocations[3] == '2');
+}
 
-  const ELF::Addr sym_addr = 0;
-  const bool resolved = false;
+// Narrow a Rela to its equivalent Rel. The r_addend field in the input
+// Rela must be zero.
+void ConvertRelaToRel(const ELF::Rela* rela, ELF::Rel* rel) {
+  assert(rela->r_addend == 0);
+  rel->r_offset = rela->r_offset;
+  rel->r_info = rela->r_info;
+}
 
-  size_t unpacked_count = 0;
+}  // namespace
 
-  // Emit relocations for each deltas pair.
-  while (pairs) {
-    offset += decoder.Dequeue();
-    addend += decoder.Dequeue();
+// Args for ApplyAndroidRelocation handler function.
+struct ApplyAndroidRelocationArgs {
+  ELF::Addr relocations_type;
+  const ElfSymbols* symbols;
+  ElfRelocations::SymbolResolver* resolver;
+  Error* error;
+};
 
-    ELF::Rela relocation;
-    relocation.r_offset = offset;
-    relocation.r_info = ELF_R_INFO(0, RELATIVE_RELOCATION_CODE);
-    relocation.r_addend = addend;
-    if (!ApplyRelaReloc(&relocation, sym_addr, resolved, error))
-      return false;
-    unpacked_count++;
-    pairs--;
+// Static ForEachAndroidRelocation() handler.
+bool ElfRelocations::ApplyAndroidRelocation(ElfRelocations* relocations,
+                                            const ELF::Rela* relocation,
+                                            void* opaque) {
+  // Unpack args from opaque.
+  ApplyAndroidRelocationArgs* args =
+      reinterpret_cast<ApplyAndroidRelocationArgs*>(opaque);
+  const ELF::Addr relocations_type = args->relocations_type;
+  const ElfSymbols* symbols = args->symbols;
+  ElfRelocations::SymbolResolver* resolver = args->resolver;
+  Error* error = args->error;
+
+  // For REL relocations, convert from RELA to REL and apply the conversion.
+  // For RELA relocations, apply RELA directly.
+  if (relocations_type == DT_REL) {
+    ELF::Rel converted;
+    ConvertRelaToRel(relocation, &converted);
+    return relocations->ApplyRelReloc(&converted, symbols, resolver, error);
   }
 
-  RLOG("%s: unpacked_count=%d\n", __FUNCTION__, unpacked_count);
+  if (relocations_type == DT_RELA)
+    return relocations->ApplyRelaReloc(relocation, symbols, resolver, error);
+
   return true;

[rmcilroy, 2015/04/13 10:36:10]

Are non DT_REL / DT_RELA relocations allowed to go through this function without
being handled?

[simonb (inactive), 2015/04/28 14:39:41]

Relocations are either DT_REL or DT_RELA, but cannot be neither.  Enforced at
lines 331-338 above.

[rmcilroy, 2015/05/01 14:15:22]

I see, that's fine.

 }
 
-bool ElfRelocations::ApplyPackedRelocations(Error* error) {
-  if (!packed_relocations_)
+bool ElfRelocations::ApplyAndroidRelocations(const ElfSymbols* symbols,
+                                             SymbolResolver* resolver,
+                                             Error* error) {
+  if (!android_relocations_)
     return true;
 
-  // Check for an initial APR1 header, packed relocations.
-  if (packed_relocations_[0] == 'A' &&
-      packed_relocations_[1] == 'P' &&
-      packed_relocations_[2] == 'R' &&
-      packed_relocations_[3] == '1') {
-    return ApplyPackedRel(packed_relocations_ + 4, error);
-  }
+  if (!IsValidAndroidPackedRelocations(android_relocations_,
+                                       android_relocations_size_))
+    return false;
 
-  // Check for an initial APA1 header, packed relocations with addend.
-  if (packed_relocations_[0] == 'A' &&
-      packed_relocations_[1] == 'P' &&
-      packed_relocations_[2] == 'A' &&
-      packed_relocations_[3] == '1') {
-    return ApplyPackedRela(packed_relocations_ + 4, error);
-  }
+  ApplyAndroidRelocationArgs args;
+  args.relocations_type = relocations_type_;
+  args.symbols = symbols;
+  args.resolver = resolver;
+  args.error = error;
+  return ForEachAndroidRelocation(&ApplyAndroidRelocation, &args);
+}
 
-  error->Format("Bad packed relocations ident, expected APR1 or APA1");
-  return false;
-}
-#endif  // __arm__ || __aarch64__
-
-bool ElfRelocations::ApplyRelaReloc(const ELF::Rela* rela,
-                                    ELF::Addr sym_addr,
-                                    bool resolved CRAZY_UNUSED,
-                                    Error* error) {
+bool ElfRelocations::ApplyResolvedRelaReloc(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_);
 
   RLOG("  rela reloc=%p offset=%p type=%d addend=%p\n",
        reloc,
        rela->r_offset,
        rela_type,
@@ skipping 71 matching lines @@
 #endif  // __x86_64__
 
     default:
       error->Format("Invalid relocation type (%d)", rela_type);
       return false;
   }
 
   return true;
 }
 
-bool ElfRelocations::ApplyRelReloc(const ELF::Rel* rel,
-                                   ELF::Addr sym_addr,
-                                   bool resolved CRAZY_UNUSED,
-                                   Error* error) {
+bool ElfRelocations::ApplyResolvedRelReloc(const ELF::Rel* rel,
+                                           ELF::Addr sym_addr,
+                                           bool resolved CRAZY_UNUSED,
+                                           Error* error) {
   const ELF::Word rel_type = ELF_R_TYPE(rel->r_info);
   const ELF::Word CRAZY_UNUSED rel_symbol = ELF_R_SYM(rel->r_info);
 
   const ELF::Addr reloc = static_cast<ELF::Addr>(rel->r_offset + load_bias_);
 
   RLOG("  rel reloc=%p offset=%p type=%d\n", reloc, rel->r_offset, rel_type);
 
   // Apply the relocation.
   ELF::Addr* CRAZY_UNUSED target = reinterpret_cast<ELF::Addr*>(reloc);
   switch (rel_type) {
@@ skipping 137 matching lines @@
     return true;
   }
 
   error->Format(
       "Invalid weak relocation type (%d) for unknown symbol '%s'",
       r,
       sym_name);
   return false;
 }
 
+bool ElfRelocations::ApplyRelReloc(const ELF::Rel* rel,
+                                   const ElfSymbols* symbols,
+                                   SymbolResolver* resolver,
+                                   Error* error) {
+  const ELF::Word rel_type = ELF_R_TYPE(rel->r_info);
+  const ELF::Word rel_symbol = ELF_R_SYM(rel->r_info);
+
+  ELF::Addr sym_addr = 0;
+  ELF::Addr reloc = static_cast<ELF::Addr>(rel->r_offset + load_bias_);
+  RLOG("  reloc=%p offset=%p type=%d symbol=%d\n",
+       reloc,
+       rel->r_offset,
+       rel_type,
+       rel_symbol);
+
+  if (rel_type == 0)
+    return true;
+
+  bool resolved = false;
+
+  // If this is a symbolic relocation, compute the symbol's address.
+  if (__builtin_expect(rel_symbol != 0, 0)) {
+    if (!ResolveSymbol(rel_type,
+                       rel_symbol,
+                       symbols,
+                       resolver,
+                       reloc,
+                       &sym_addr,
+                       error)) {
+      return false;
+    }
+    resolved = true;
+  }
+
+  return ApplyResolvedRelReloc(rel, sym_addr, resolved, error);
+}
+
 bool ElfRelocations::ApplyRelRelocs(const ELF::Rel* rel,
                                     size_t rel_count,
                                     const ElfSymbols* symbols,
                                     SymbolResolver* resolver,
                                     Error* error) {
   RLOG("%s: rel=%p rel_count=%d\n", __FUNCTION__, rel, rel_count);
 
   if (!rel)
     return true;
 
   for (size_t rel_n = 0; rel_n < rel_count; rel++, rel_n++) {
-    const ELF::Word rel_type = ELF_R_TYPE(rel->r_info);
-    const ELF::Word rel_symbol = ELF_R_SYM(rel->r_info);
+    RLOG("  Relocation %d of %d:\n", rel_n + 1, rel_count);
 
-    ELF::Addr sym_addr = 0;
-    ELF::Addr reloc = static_cast<ELF::Addr>(rel->r_offset + load_bias_);
-    RLOG("  %d/%d reloc=%p offset=%p type=%d symbol=%d\n",
-         rel_n + 1,
-         rel_count,
-         reloc,
-         rel->r_offset,
-         rel_type,
-         rel_symbol);
-
-    if (rel_type == 0)
-      continue;
-
-    bool resolved = false;
-
-    // If this is a symbolic relocation, compute the symbol's address.
-    if (__builtin_expect(rel_symbol != 0, 0)) {
-      if (!ResolveSymbol(rel_type,
-                         rel_symbol,
-                         symbols,
-                         resolver,
-                         reloc,
-                         &sym_addr,
-                         error)) {
-        return false;
-      }
-      resolved = true;
-    }
-
-    if (!ApplyRelReloc(rel, sym_addr, resolved, error))
+    if (!ApplyRelReloc(rel, symbols, resolver, error))
       return false;
   }
 
   return true;
 }
 
+bool ElfRelocations::ApplyRelaReloc(const ELF::Rela* rela,

[rmcilroy, 2015/04/13 10:36:10]

Could you template this with ApplyRelReloc? Not sure if this would be a net
simplifcation (plus more templating...) but there is a fair amount of code
shared here.

[simonb (inactive), 2015/04/28 14:39:41]

Possible, but the result doesn't aid readability much, and forces templating
onto ApplyResolvedRel[a]Reloc() also.  This is part of the original crazy linker
code, so I've left it for now.

[rmcilroy, 2015/05/01 14:15:22]

Acknowledged.

+                                    const ElfSymbols* symbols,
+                                    SymbolResolver* resolver,
+                                    Error* error) {
+  const ELF::Word rel_type = ELF_R_TYPE(rela->r_info);
+  const ELF::Word rel_symbol = ELF_R_SYM(rela->r_info);
+
+  ELF::Addr sym_addr = 0;
+  ELF::Addr reloc = static_cast<ELF::Addr>(rela->r_offset + load_bias_);
+  RLOG("  reloc=%p offset=%p type=%d symbol=%d\n",
+       reloc,
+       rela->r_offset,
+       rel_type,
+       rel_symbol);
+
+  if (rel_type == 0)
+    return true;
+
+  bool resolved = false;
+
+  // If this is a symbolic relocation, compute the symbol's address.
+  if (__builtin_expect(rel_symbol != 0, 0)) {
+    if (!ResolveSymbol(rel_type,
+                       rel_symbol,
+                       symbols,
+                       resolver,
+                       reloc,
+                       &sym_addr,
+                       error)) {
+      return false;
+    }
+    resolved = true;
+  }
+
+  return ApplyResolvedRelaReloc(rela, sym_addr, resolved, error);
+}
+
 bool ElfRelocations::ApplyRelaRelocs(const ELF::Rela* rela,
                                      size_t rela_count,
                                      const ElfSymbols* symbols,
                                      SymbolResolver* resolver,
                                      Error* error) {
   RLOG("%s: rela=%p rela_count=%d\n", __FUNCTION__, rela, rela_count);
 
   if (!rela)
     return true;
 
   for (size_t rel_n = 0; rel_n < rela_count; rela++, rel_n++) {
-    const ELF::Word rel_type = ELF_R_TYPE(rela->r_info);
-    const ELF::Word rel_symbol = ELF_R_SYM(rela->r_info);
+    RLOG("  Relocation %d of %d:\n", rel_n + 1, rela_count);
 
-    ELF::Addr sym_addr = 0;
-    ELF::Addr reloc = static_cast<ELF::Addr>(rela->r_offset + load_bias_);
-    RLOG("  %d/%d reloc=%p offset=%p type=%d symbol=%d\n",
-         rel_n + 1,
-         rela_count,
-         reloc,
-         rela->r_offset,
-         rel_type,
-         rel_symbol);
-
-    if (rel_type == 0)
-      continue;
-
-    bool resolved = false;
-
-    // If this is a symbolic relocation, compute the symbol's address.
-    if (__builtin_expect(rel_symbol != 0, 0)) {
-      if (!ResolveSymbol(rel_type,
-                         rel_symbol,
-                         symbols,
-                         resolver,
-                         reloc,
-                         &sym_addr,
-                         error)) {
-        return false;
-      }
-      resolved = true;
-    }
-
-    if (!ApplyRelaReloc(rela, sym_addr, resolved, error))
+    if (!ApplyRelaReloc(rela, symbols, resolver, error))
       return false;
   }
 
   return true;
 }
 
 #ifdef __mips__
 bool ElfRelocations::RelocateMipsGot(const ElfSymbols* symbols,
                                      SymbolResolver* resolver,
                                      Error* error) {
@@ skipping 75 matching lines @@
 #ifdef __mips__
     case R_MIPS_REL32:
       *dst_ptr += map_delta;
       break;
 #endif
     default:
       ;
   }
 }
 
+// Args for ApplyAndroidRelocation handler function.
+struct RelocateAndroidRelocationArgs {

[rmcilroy, 2015/04/13 10:36:10]

nit - move down to just above RelocateAndroidRelocation

[simonb (inactive), 2015/04/28 14:39:41]

Done.

+  size_t src_addr;
+  size_t dst_addr;
+  size_t map_addr;
+  size_t size;
+};
+
+void ElfRelocations::RelocateAndroidReloc(const ELF::Rela* relocation,
+                                          size_t src_addr,
+                                          size_t dst_addr,
+                                          size_t map_addr,
+                                          size_t size) {
+  // Add this value to each source address to get the corresponding
+  // destination address.
+  const size_t dst_delta = dst_addr - src_addr;
+  const size_t map_delta = map_addr - src_addr;
+
+  const ELF::Word rel_type = ELF_R_TYPE(relocation->r_info);
+  const ELF::Word rel_symbol = ELF_R_SYM(relocation->r_info);
+  ELF::Addr src_reloc =
+      static_cast<ELF::Addr>(relocation->r_offset + load_bias_);
+
+  if (rel_type == 0 || rel_symbol != 0) {
+    // Ignore empty and symbolic relocations
+    return;
+  }
+
+  if (src_reloc < src_addr || src_reloc >= src_addr + size) {
+    // Ignore entries that don't relocate addresses inside the source section.
+    return;
+  }
+
+  AdjustRelocation(rel_type, src_reloc, dst_delta, map_delta);
+}
+
+// Static ForEachAndroidRelocation() handler.
+bool ElfRelocations::RelocateAndroidRelocation(ElfRelocations* relocations,
+                                               const ELF::Rela* relocation,
+                                               void* opaque) {
+  // Unpack args from opaque, to obtain addrs and size;
+  RelocateAndroidRelocationArgs* args =
+      reinterpret_cast<RelocateAndroidRelocationArgs*>(opaque);
+  const size_t src_addr = args->src_addr;
+  const size_t dst_addr = args->dst_addr;
+  const size_t map_addr = args->map_addr;
+  const size_t size = args->size;
+
+  // Relocate the given relocation.  Because the r_addend field is ignored
+  // in relocating RELA relocations we do not need to convert from REL to
+  // RELA and supply alternative relocator functions; instead we can work
+  // here directly on the RELA supplied by ForEachAndroidRelocation(), even
+  // on REL architectures.
+  relocations->RelocateAndroidReloc(relocation,
+                                    src_addr, dst_addr, map_addr, size);
+  return true;
+}
+
+void ElfRelocations::RelocateAndroidRelocations(size_t src_addr,
+                                                size_t dst_addr,
+                                                size_t map_addr,
+                                                size_t size) {
+  if (!android_relocations_)
+    return;
+
+  assert(IsValidAndroidPackedRelocations(android_relocations_,
+                                         android_relocations_size_));
+
+  RelocateAndroidRelocationArgs args;
+  args.src_addr = src_addr;
+  args.dst_addr = dst_addr;
+  args.map_addr = map_addr;
+  args.size = size;
+  ForEachAndroidRelocation(&RelocateAndroidRelocation, &args);
+}
+
 void ElfRelocations::RelocateRela(size_t src_addr,
                                   size_t dst_addr,
                                   size_t map_addr,
                                   size_t size) {
   // Add this value to each source address to get the corresponding
   // destination address.
   const size_t dst_delta = dst_addr - src_addr;
   const size_t map_delta = map_addr - src_addr;
 
   // Ignore PLT relocations, which all target symbols (ignored here).
@@ skipping 55 matching lines @@
 
 void ElfRelocations::CopyAndRelocate(size_t src_addr,
                                      size_t dst_addr,
                                      size_t map_addr,
                                      size_t size) {
   // First, a straight copy.
   ::memcpy(reinterpret_cast<void*>(dst_addr),
            reinterpret_cast<void*>(src_addr),
            size);
 
+  // Relocate android relocations.
+  RelocateAndroidRelocations(src_addr, dst_addr, map_addr, size);
+
   // Relocate relocations.
   if (relocations_type_ == DT_REL)
     RelocateRel(src_addr, dst_addr, map_addr, size);
 
   if (relocations_type_ == DT_RELA)
     RelocateRela(src_addr, dst_addr, map_addr, size);
 
 #ifdef __mips__
   // Add this value to each source address to get the corresponding
   // destination address.
   const size_t dst_delta = dst_addr - src_addr;
   const size_t map_delta = map_addr - src_addr;
 
   // Only relocate local GOT entries.
   ELF::Addr* got = plt_got_;
   if (got) {
     for (ELF::Addr n = 2; n < mips_local_got_count_; ++n) {
       size_t got_addr = reinterpret_cast<size_t>(&got[n]);
       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