crazy linker: convert relocation unpacking to Android style.

third_party/android_crazy_linker/src/src/crazy_linker_shared_library.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_shared_library.h"
 
 #include <dlfcn.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <elf.h>
@@ skipping 40 matching lines @@
 #endif
 
 #ifndef DT_PREINIT_ARRAY
 #define DT_PREINIT_ARRAY 32
 #endif
 
 #ifndef DT_PREINIT_ARRAYSZ
 #define DT_PREINIT_ARRAYSZ 33
 #endif
 
-#ifndef DT_LOOS
-#define DT_LOOS 0x6000000d
-#endif
-
-// Extension dynamic tags for packed relocations.
-#if defined(__arm__) || defined(__aarch64__)
-
-#define DT_ANDROID_REL_OFFSET (DT_LOOS)
-#define DT_ANDROID_REL_SIZE (DT_LOOS + 1)
-
-#endif  // __arm__ || __aarch64__
-
 namespace crazy {
 
 namespace {
 
 typedef SharedLibrary::linker_function_t linker_function_t;
 typedef int (*JNI_OnLoadFunctionPtr)(void* vm, void* reserved);
 typedef void (*JNI_OnUnloadFunctionPtr)(void* vm, void* reserved);
 
 // Call a constructor or destructor function pointer. Ignore
 // NULL and -1 values intentionally. They correspond to markers
@@ skipping 104 matching lines @@
 
     return NULL;
   }
 
   void* main_program_handle_;
   SharedLibrary* lib_;
   Vector<LibraryView*>* preloads_;
   Vector<LibraryView*>* dependencies_;
 };
 
-#if defined(__arm__) || defined(__aarch64__)
-
-// Helper class to provide a simple scoped buffer.  ScopedPtr is not
-// usable here because it calls delete, not delete [].
-class ScopedBuffer {
- public:
-  explicit ScopedBuffer(size_t bytes) : buffer_(new uint8_t[bytes]) { }
-  ~ScopedBuffer() { delete [] buffer_; }
-
-  uint8_t* Get() { return buffer_; }
-
-  uint8_t* Release() {
-    uint8_t* ptr = buffer_;
-    buffer_ = NULL;
-    return ptr;
-  }
-
- private:
-  uint8_t* buffer_;
-};
-
-// Read an .android.rel.dyn packed relocations section.
-// Returns an allocated buffer holding the data, or NULL on error.
-uint8_t* ReadPackedRelocations(const char* full_path,
-                               off_t offset,
-                               size_t bytes,
-                               Error* error) {
-  FileDescriptor fd;
-  if (!fd.OpenReadOnly(full_path)) {
-    error->Format("Error opening file '%s'", full_path);
-    return NULL;
-  }
-  if (fd.SeekTo(offset) == -1) {
-    error->Format("Error seeking to %d in file '%s'", offset, full_path);
-    return NULL;
-  }
-
-  ScopedBuffer buffer(bytes);
-  const ssize_t bytes_read = fd.Read(buffer.Get(), bytes);
-  if (static_cast<size_t>(bytes_read) != bytes) {
-    error->Format("Error reading %d bytes from file '%s'", bytes, full_path);
-    return NULL;
-  }
-  fd.Close();
-
-  uint8_t* packed_data = buffer.Release();
-  return packed_data;
-}
-
-#endif  // __arm__ || __aarch64__
-
 }  // namespace
 
 SharedLibrary::SharedLibrary() { ::memset(this, 0, sizeof(*this)); }
 
 SharedLibrary::~SharedLibrary() {
   // Ensure the library is unmapped on destruction.
   if (view_.load_address())
     munmap(reinterpret_cast<void*>(view_.load_address()), view_.load_size());
-
-#if defined(__arm__) || defined(__aarch64__)
-  delete [] packed_relocations_;
-#endif
 }
 
 bool SharedLibrary::Load(const char* full_path,
                          size_t load_address,
                          size_t file_offset,
                          Error* error) {
   // First, record the path.
   LOG("%s: full path '%s'\n", __FUNCTION__, full_path);
 
   size_t full_path_len = strlen(full_path);
@@ skipping 35 matching lines @@
     relro_start_ = 0;
     relro_size_ = 0;
   }
 
 #ifdef __arm__
   LOG("%s: Extracting ARM.exidx table for %s\n", __FUNCTION__, base_name_);
   (void)phdr_table_get_arm_exidx(
       phdr(), phdr_count(), load_bias(), &arm_exidx_, &arm_exidx_count_);
 #endif
 
-#if defined(__arm__) || defined(__aarch64__)
-  off_t packed_relocations_offset = 0;
-  size_t packed_relocations_size = 0;
-#endif
-
   LOG("%s: Parsing dynamic table for %s\n", __FUNCTION__, base_name_);
   ElfView::DynamicIterator dyn(&view_);
   for (; dyn.HasNext(); dyn.GetNext()) {
     ELF::Addr dyn_value = dyn.GetValue();
     uintptr_t dyn_addr = dyn.GetAddress(load_bias());
     switch (dyn.GetTag()) {
       case DT_DEBUG:
         if (view_.dynamic_flags() & PF_W) {
           *dyn.GetValuePointer() =
               reinterpret_cast<uintptr_t>(Globals::GetRDebug()->GetAddress());
@@ skipping 38 matching lines @@
             preinit_array_count_);
         break;
       case DT_SYMBOLIC:
         LOG("  DT_SYMBOLIC\n");
         has_DT_SYMBOLIC_ = true;
         break;
       case DT_FLAGS:
         if (dyn_value & DF_SYMBOLIC)
           has_DT_SYMBOLIC_ = true;
         break;
-#if defined(__arm__) || defined(__aarch64__)
-      case DT_ANDROID_REL_OFFSET:
-        packed_relocations_offset = dyn.GetOffset();
-        LOG("  DT_ANDROID_REL_OFFSET addr=%p\n", packed_relocations_offset);
-        break;
-      case DT_ANDROID_REL_SIZE:
-        packed_relocations_size = dyn.GetValue();
-        LOG("  DT_ANDROID_REL_SIZE=%d\n", packed_relocations_size);
-        break;
-#endif
 #if defined(__mips__)
       case DT_MIPS_RLD_MAP:
         *dyn.GetValuePointer() =
             reinterpret_cast<ELF::Addr>(Globals::GetRDebug()->GetAddress());
         break;
 #endif
       default:
         ;
     }
   }
 
-#if defined(__arm__) || defined(__aarch64__)
-  // If packed relocations are present in the target library, read the
-  // section data and save it in packed_relocations_.
-  if (packed_relocations_offset && packed_relocations_size) {
-    LOG("%s: Packed relocations found at offset %d, %d bytes\n",
-        __FUNCTION__,
-        packed_relocations_offset,
-        packed_relocations_size);
-
-    packed_relocations_ =
-        ReadPackedRelocations(full_path,
-                              packed_relocations_offset + file_offset,
-                              packed_relocations_size,
-                              error);
-    if (!packed_relocations_)
-      return false;
-
-    LOG("%s: Packed relocations stored at %p\n",
-        __FUNCTION__,
-        packed_relocations_);
-
-    // Add packed relocations to the view.
-    view_.RegisterPackedRelocations(packed_relocations_);
-  }
-#endif
-
   LOG("%s: Load complete for %s\n", __FUNCTION__, base_name_);
   return true;
 }
 
 bool SharedLibrary::Relocate(LibraryList* lib_list,
                              Vector<LibraryView*>* preloads,
                              Vector<LibraryView*>* dependencies,
                              Error* error) {
   // Apply relocations.
   LOG("%s: Applying relocations to %s\n", __FUNCTION__, base_name_);
@@ skipping 149 matching lines @@
     if (iter_.GetTag() == DT_NEEDED) {
       dep_name_ = symbols_->GetStringById(iter_.GetValue());
       iter_.GetNext();
       return true;
     }
   }
   return false;
 }
 
 }  // namespace crazy