Crazy Linker: Refactor to be closer to upstream linker's code

No change in behavior expected.

Main changes:
* Use of upstream's linker_reloc_iterators.h & linker_sleb128.h.
* Use #ifdefs to choose between 32 and 64 bit.

Upstream linker:
https://android.googlesource.com/platform/bionic/+/master/linker/linker.cpp

TBR=digit

Change-Id: I15c0fadadbfcd99dae4e334a205b69e875c4cce1
Reviewed-on: https://chromium-review.googlesource.com/879222Reviewed-by: agrieve <agrieve@chromium.org>
Commit-Queue: agrieve <agrieve@chromium.org>
Cr-Commit-Position: refs/heads/master@{#531298}

third_party/android_crazy_linker/BUILD.gn

@@ -32,7 +32,6 @@ source_set("android_crazy_linker") {
     "src/src/crazy_linker_error.h",
     "src/src/crazy_linker_globals.cpp",
     "src/src/crazy_linker_globals.h",
-    "src/src/crazy_linker_leb128.h",
     "src/src/crazy_linker_library_list.cpp",
     "src/src/crazy_linker_library_list.h",
     "src/src/crazy_linker_library_view.cpp",
@@ -61,10 +60,11 @@ source_set("android_crazy_linker") {
     "src/src/elf_traits.h",
     "src/src/linker_phdr.cpp",
     "src/src/linker_phdr.h",
+    "src/src/linker_reloc_iterators.h",
+    "src/src/linker_sleb128.h",
   ]
 
   include_dirs = [ "src/src" ]
-  defines = [ "CRAZY_DEBUG=0" ]
 
   public_configs = [ ":crazy_config" ]
   configs -= [ "//build/config/compiler:chromium_code" ]

third_party/android_crazy_linker/src/src/crazy_linker_defines.h

+// Copyright 2017 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.
+
+// Comes from bionic/linker/linker_common_types.h
+// Android uses RELA for aarch64 and x86_64. mips64 still uses REL.
+#if defined(__aarch64__) || defined(__x86_64__)
+// USE_RELA means relocations have explicit addends.
+#define USE_RELA 1
+#endif

third_party/android_crazy_linker/src/src/crazy_linker_elf_relocations.h

@@ -8,6 +8,9 @@
 #include <string.h>
 #include <unistd.h>
 
+#include <link.h>
+
+#include "crazy_linker_defines.h"
 #include "elf_traits.h"
 
 namespace crazy {
@@ -19,6 +22,11 @@ class Error;
 // An ElfRelocations instance holds information about relocations in a mapped
 // ELF binary.
 class ElfRelocations {
+#if defined(USE_RELA)
+  typedef ELF::Rela rel_t;
+#else
+  typedef ELF::Rel rel_t;
+#endif
  public:
   ElfRelocations() { ::memset(this, 0, sizeof(*this)); }
   ~ElfRelocations() {}
@@ -64,42 +72,28 @@ class ElfRelocations {
                      ELF::Addr reloc,
                      ELF::Addr* sym_addr,
                      Error* error);
-  bool ApplyResolvedRelaReloc(const ELF::Rela* rela,
-                              ELF::Addr sym_addr,
-                              bool resolved,
-                              Error* error);
-  bool ApplyResolvedRelReloc(const ELF::Rel* rel,
-                             ELF::Addr sym_addr,
-                             bool resolved,
-                             Error* error);
-  bool ApplyRelaReloc(const ELF::Rela* rela,
-                      const ElfSymbols* symbols,
-                      SymbolResolver* resolver,
-                      Error* error);
-  bool ApplyRelReloc(const ELF::Rel* rel,
-                     const ElfSymbols* symbols,
-                     SymbolResolver* resolver,
-                     Error* error);
-  bool ApplyRelaRelocs(const ELF::Rela* relocs,
-                       size_t relocs_count,
-                       const ElfSymbols* symbols,
-                       SymbolResolver* resolver,
-                       Error* error);
-  bool ApplyRelRelocs(const ELF::Rel* relocs,
-                      size_t relocs_count,
-                      const ElfSymbols* symbols,
-                      SymbolResolver* resolver,
-                      Error* error);
+  bool ApplyResolvedReloc(const rel_t* rela,
+                          ELF::Addr sym_addr,
+                          bool resolved,
+                          Error* error);
+  bool ApplyReloc(const rel_t* rela,
+                  const ElfSymbols* symbols,
+                  SymbolResolver* resolver,
+                  Error* error);
+  bool ApplyRelocs(const rel_t* relocs,
+                   size_t relocs_count,
+                   const ElfSymbols* symbols,
+                   SymbolResolver* resolver,
+                   Error* error);
   void AdjustRelocation(ELF::Word rel_type,
                         ELF::Addr src_reloc,
                         size_t dst_delta,
                         size_t map_delta);
-  template<typename Rel>
   void RelocateRelocations(size_t src_addr,
                           size_t dst_addr,
                           size_t map_addr,
                           size_t size);
-  void AdjustAndroidRelocation(const ELF::Rela* relocation,
+  void AdjustAndroidRelocation(const rel_t* relocation,
                                size_t src_addr,
                                size_t dst_addr,
                                size_t map_addr,
@@ -108,10 +102,14 @@ class ElfRelocations {
   // Android packed relocations unpacker. Calls the given handler for
   // each relocation in the unpacking stream.
   typedef bool (*RelocationHandler)(ElfRelocations* relocations,
-                                    const ELF::Rela* relocation,
+                                    const rel_t* relocation,
                                     void* opaque);
   bool ForEachAndroidRelocation(RelocationHandler handler,
                                 void* opaque);
+  template <typename ElfRelIteratorT>
+  bool ForEachAndroidRelocationHelper(ElfRelIteratorT&& rel_iterator,
+                                      ElfRelocations::RelocationHandler handler,
+                                      void* opaque);
 
   // Apply Android packed relocations.
   // On error, return false and set |error| message.
@@ -120,7 +118,7 @@ class ElfRelocations {
                                SymbolResolver* resolver,
                                Error* error);
   static bool ApplyAndroidRelocation(ElfRelocations* relocations,
-                                     const ELF::Rela* relocation,
+                                     const rel_t* relocation,
                                      void* opaque);
 
   // Relocate Android packed relocations.
@@ -130,7 +128,7 @@ class ElfRelocations {
                                   size_t map_addr,
                                   size_t size);
   static bool RelocateAndroidRelocation(ElfRelocations* relocations,
-                                        const ELF::Rela* relocation,
+                                        const rel_t* relocation,
                                         void* opaque);
 
 #if defined(__mips__)
@@ -143,7 +141,6 @@ class ElfRelocations {
   size_t phdr_count_;
   size_t load_bias_;
 
-  ELF::Addr relocations_type_;
   ELF::Addr plt_relocations_;
   size_t plt_relocations_size_;
   ELF::Addr* plt_got_;

third_party/android_crazy_linker/src/src/linker_reloc_iterators.h

+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef __LINKER_RELOC_ITERATORS_H
+#define __LINKER_RELOC_ITERATORS_H
+
+#include <string.h>
+
+#include <link.h>
+
+#include "crazy_linker_debug.h"
+#include "crazy_linker_defines.h"
+
+const size_t RELOCATION_GROUPED_BY_INFO_FLAG = 1;
+const size_t RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG = 2;
+const size_t RELOCATION_GROUPED_BY_ADDEND_FLAG = 4;
+const size_t RELOCATION_GROUP_HAS_ADDEND_FLAG = 8;
+
+class plain_reloc_iterator {
+#if defined(USE_RELA)
+  typedef ElfW(Rela) rel_t;
+#else
+  typedef ElfW(Rel) rel_t;
+#endif
+ public:
+  plain_reloc_iterator(rel_t* rel_array, size_t count)
+      : begin_(rel_array), end_(begin_ + count), current_(begin_) {}
+
+  bool has_next() { return current_ < end_; }
+
+  rel_t* next() { return current_++; }
+
+ private:
+  rel_t* const begin_;
+  rel_t* const end_;
+  rel_t* current_;
+};
+
+template <typename decoder_t>
+class packed_reloc_iterator {
+#if defined(USE_RELA)
+  typedef ElfW(Rela) rel_t;
+#else
+  typedef ElfW(Rel) rel_t;
+#endif
+ public:
+  explicit packed_reloc_iterator(decoder_t&& decoder) : decoder_(decoder) {
+    // initialize fields
+    memset(&reloc_, 0, sizeof(reloc_));
+    relocation_count_ = decoder_.pop_front();
+    reloc_.r_offset = decoder_.pop_front();
+    relocation_index_ = 0;
+    relocation_group_index_ = 0;
+    group_size_ = 0;
+  }
+
+  bool has_next() const { return relocation_index_ < relocation_count_; }
+
+  rel_t* next() {
+    if (relocation_group_index_ == group_size_) {
+      if (!read_group_fields()) {
+        // Iterator is inconsistent state; it should not be called again
+        // but in case it is let's make sure has_next() returns false.
+        relocation_index_ = relocation_count_ = 0;
+        return nullptr;
+      }
+    }
+
+    if (is_relocation_grouped_by_offset_delta()) {
+      reloc_.r_offset += group_r_offset_delta_;
+    } else {
+      reloc_.r_offset += decoder_.pop_front();
+    }
+
+    if (!is_relocation_grouped_by_info()) {
+      reloc_.r_info = decoder_.pop_front();
+    }
+
+#if defined(USE_RELA)
+    if (is_relocation_group_has_addend() &&
+        !is_relocation_grouped_by_addend()) {
+      reloc_.r_addend += decoder_.pop_front();
+    }
+#endif
+
+    relocation_index_++;
+    relocation_group_index_++;
+
+    return &reloc_;
+  }
+
+ private:
+  bool read_group_fields() {
+    group_size_ = decoder_.pop_front();
+    group_flags_ = decoder_.pop_front();
+
+    if (is_relocation_grouped_by_offset_delta()) {
+      group_r_offset_delta_ = decoder_.pop_front();
+    }
+
+    if (is_relocation_grouped_by_info()) {
+      reloc_.r_info = decoder_.pop_front();
+    }
+
+    if (is_relocation_group_has_addend() && is_relocation_grouped_by_addend()) {
+#if !defined(USE_RELA)
+      // This platform does not support rela, and yet we have it encoded in
+      // android_rel section.
+      LOG("unexpected r_addend in android.rel section");
+      return false;
+#else
+      reloc_.r_addend += decoder_.pop_front();
+    } else if (!is_relocation_group_has_addend()) {
+      reloc_.r_addend = 0;
+#endif
+    }
+
+    relocation_group_index_ = 0;
+    return true;
+  }
+
+  bool is_relocation_grouped_by_info() {
+    return (group_flags_ & RELOCATION_GROUPED_BY_INFO_FLAG) != 0;
+  }
+
+  bool is_relocation_grouped_by_offset_delta() {
+    return (group_flags_ & RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG) != 0;
+  }
+
+  bool is_relocation_grouped_by_addend() {
+    return (group_flags_ & RELOCATION_GROUPED_BY_ADDEND_FLAG) != 0;
+  }
+
+  bool is_relocation_group_has_addend() {
+    return (group_flags_ & RELOCATION_GROUP_HAS_ADDEND_FLAG) != 0;
+  }
+
+  decoder_t decoder_;
+  size_t relocation_count_;
+  size_t group_size_;
+  size_t group_flags_;
+  size_t group_r_offset_delta_;
+  size_t relocation_index_;
+  size_t relocation_group_index_;
+  rel_t reloc_;
+};
+
+#endif  // __LINKER_RELOC_ITERATORS_H

third_party/android_crazy_linker/src/src/crazy_linker_leb128.h → third_party/android_crazy_linker/src/src/linker_sleb128.h

-// 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.
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
 
-#ifndef CRAZY_LINKER_LEB128_H
-#define CRAZY_LINKER_LEB128_H
+#ifndef _LINKER_SLEB128_H
+#define _LINKER_SLEB128_H
 
 #include <assert.h>
 #include <stdint.h>
@@ -11,16 +35,16 @@
 // Helper classes for decoding LEB128, used in packed relocation data.
 // http://en.wikipedia.org/wiki/LEB128
 
-namespace crazy {
-
-class Sleb128Decoder {
+class sleb128_decoder {
  public:
-  Sleb128Decoder(const uint8_t* buffer, size_t count) : current_(buffer)
+  sleb128_decoder(const uint8_t* buffer, size_t count)
+      : current_(buffer)
 #ifndef NDEBUG
-      , end_(buffer + count)
+        ,
+        end_(buffer + count)
 #endif
-  {}
-
+  {
+  }
   size_t pop_front() {
     size_t value = 0;
     static const size_t size = CHAR_BIT * sizeof(value);
@@ -30,7 +54,6 @@ class Sleb128Decoder {
 
     do {
       assert(current_ < end_);
-
       byte = *current_++;
       value |= (static_cast<size_t>(byte & 127) << shift);
       shift += 7;
@@ -50,6 +73,4 @@ class Sleb128Decoder {
 #endif
 };
 
-}  // namespace crazy
-
-#endif  // CRAZY_LINKER_LEB128_H
+#endif  // __LINKER_SLEB128_H