This patch adds a new third-party library that implements an ELF dynamic linker.

third_party/crazy_linker/crazy_linker/src/crazy_linker_elf_relocator.h

Index: third_party/crazy_linker/crazy_linker/src/crazy_linker_elf_relocator.h
diff --git a/third_party/crazy_linker/crazy_linker/src/crazy_linker_elf_relocator.h b/third_party/crazy_linker/crazy_linker/src/crazy_linker_elf_relocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e0feb7fef8f8bd85c3e267e06100d1da2024052
--- /dev/null
+++ b/third_party/crazy_linker/crazy_linker/src/crazy_linker_elf_relocator.h
@@ -0,0 +1,105 @@
+// Copyright (c) 2013 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.
+
+#ifndef CRAZY_LINKER_ELF_RELOCATOR_H
+#define CRAZY_LINKER_ELF_RELOCATOR_H
+
+#include "crazy_linker_error.h"
+#include "elf_traits.h"
+
+namespace crazy {
+
+// A class used to perform ELF relocations in a library.
+// Usage is:
+//   1/ Create new instance.
+//   2/ Call Init().
+//   3/ Call Apply() to apply all relocations.
+//
+// If any of these steps fail, the library will be in inconsistent
+// state and must be unloaded/unmapped as soon as possible by the
+// caller to avoid any issue.
+class ElfRelocator {
+public:
+  // Abstract class used to resolve symbol names into addresses.
+  // Callers of ::Apply() should pass the address of a derived class
+  // that properly implements the Lookup() method.
+  class SymbolResolver {
+  public:
+    SymbolResolver() {}
+    ~SymbolResolver() {}
+    virtual void* Lookup(const char* symbol_name) = 0;
+  };
+
+  ElfRelocator();
+
+  // Initialize the relocator. This will parse the library's dynamic
+  // table to populate the structure.
+  // |phdr| is the library's program header address.
+  // |phdr_count| is the number of program header entries.
+  // |load_bias| is the library load bias.
+  // |dynamic| is the library's dynamic table.
+  // |dyn_count| is the number of dynamic table entries.
+  // On failure, return false and sets the |error| message.
+  bool Init(const ELF::Phdr* phdr,
+            size_t           phdr_count,
+            size_t           load_bias,
+            const ELF::Dyn*  dynamic,
+            size_t           dyn_count,
+            Error*           error);
+
+  // After initialization, apply all relocations in the library.
+  // |resolver| must be an non-abstract instance of SymbolResolver
+  // that will be used to resolve symbol lookups during relocations.
+  // |string_table| is the library's string table.
+  // |symbol_table| is the library's symbol table.
+  // On failure, returns false and sets the |error| message.
+  bool Apply(SymbolResolver* resolver,
+             const char* string_table,
+             const ELF::Sym* symbol_table,
+             Error* error);
+
+private:
+  bool ApplyRelocs(const ELF::Rel* rel, size_t rel_count, Error* error);
+
+#ifdef __mips__
+  bool RelocateMipsGot(Error* error);
+#endif
+
+  // Program header table
+  const ELF::Phdr* phdr_;
+  size_t           phdr_count_;
+
+  // Load bias to apply to all virtual address in the library.
+  size_t           load_bias_;
+
+  // Relocations for the GOT and the PLT section that contains
+  // the trampolines to call external symbols.
+  unsigned* plt_got_;
+  ELF::Rel* plt_rel_;
+  size_t    plt_rel_count_;
+
+  // Relocations for the rest of the library.
+  ELF::Rel* rel_;
+  size_t    rel_count_;
+
+  // MIPS-specific relocation fields.
+#if defined(__mips__)
+  unsigned mips_symtabno_;
+  unsigned mips_local_gotno_;
+  unsigned mips_gotsym_;
+#endif
+
+  bool has_text_relocations_;
+  bool has_symbolic_;
+
+  // Used only during Apply().
+  SymbolResolver* resolver_;
+  const char* string_table_;
+  const ELF::Sym* symbol_table_;
+};
+
+}  // namespace crazy
+
+
+#endif  // CRAZY_LINKER_ELF_RELOCATOR_H