Android: Add chrome-specific dynamic linker.

third_party/crazy_linker/crazy_linker/src/linker_phdr.h

Index: third_party/crazy_linker/crazy_linker/src/linker_phdr.h
diff --git a/third_party/crazy_linker/crazy_linker/src/linker_phdr.h b/third_party/crazy_linker/crazy_linker/src/linker_phdr.h
new file mode 100644
index 0000000000000000000000000000000000000000..b31dde623762647029474ad884930cb0eb5416dc
--- /dev/null
+++ b/third_party/crazy_linker/crazy_linker/src/linker_phdr.h
@@ -0,0 +1,90 @@
+// 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.
+
+/*
+ * Copyright (C) 2012 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_PHDR_H
+#define LINKER_PHDR_H
+
+/* Declarations related to the ELF program header table and segments.
+ *
+ * The design goal is to provide an API that is as close as possible
+ * to the ELF spec, and does not depend on linker-specific data
+ * structures (e.g. the exact layout of struct soinfo).
+ */
+
+#include "elf_traits.h"
+
+size_t
+phdr_table_get_load_size(const ELF::Phdr* phdr_table,

[Nico, 2013/09/08 21:24:57]

Is this going to cause ODR violations with the same functions in the android
linker? Is the assumption that the android linker's version of these will always
have internal linkage? (I guess that's a good assumption for a linker, and
crazy_linker is built with fvisibility=hidden too)

[digit1, 2013/09/10 09:23:30]

There won't be any violations since:

- The crazy linker is built with -fvisibility=hidden by default. Only the
crazy_xxxx functions
  declared in <crazy_linker.h> are actually exposed explicitely through the
_CRAZY_PUBLIC
  annotation macro.

- The system linker is built with the same flags. Moreover, its build system
uses objcopy to
  rename all functions (local or global) with a '__dl_' prefix.

While we're on it, the system linker's official exported symbols (dlopen, etc)
are exposed to
loaded binaries through a special in-memory ELF file matching 'libdl.so' (where
the functions
are supposed to be defined). The symbol entries are linked to the linker's
internal implementation
of the functions (e.g. "dlopen" --> __dl_dlopen)

libdl.so itself is actually an empty "shell" library. All symbols it exposes
(e.g. dlopen())
are backed by empty functions in the library. That's because this enough at link
time (i.e.
when generating some binary with -ldl). At runtime, the in-memory ELF
representation will
override the system library, which will never be loaded.

+                         size_t phdr_count,
+                         ELF::Addr* min_vaddr = NULL,
+                         ELF::Addr* max_vaddr = NULL);
+
+int
+phdr_table_protect_segments(const ELF::Phdr* phdr_table,
+                            int              phdr_count,
+                            ELF::Addr        load_bias);
+
+int
+phdr_table_unprotect_segments(const ELF::Phdr* phdr_table,
+                              int              phdr_count,
+                              ELF::Addr        load_bias);
+
+int
+phdr_table_get_relro_info(const ELF::Phdr* phdr_table,
+                          int              phdr_count,
+                          ELF::Addr        load_bias,
+                          ELF::Addr*       relro_start,
+                          ELF::Addr*       relro_size);
+
+int
+phdr_table_protect_gnu_relro(const ELF::Phdr* phdr_table,
+                             int              phdr_count,
+                             ELF::Addr        load_bias);
+
+
+#ifdef __arm__
+int
+phdr_table_get_arm_exidx(const ELF::Phdr* phdr_table,
+                         int              phdr_count,
+                         ELF::Addr        load_bias,
+                         ELF::Addr**      arm_exidx,
+                         unsigned*        arm_exidix_count);
+#endif
+
+void
+phdr_table_get_dynamic_section(const ELF::Phdr* phdr_table,
+                               int              phdr_count,
+                               ELF::Addr        load_bias,
+                               ELF::Dyn**       dynamic,
+                               size_t*          dynamic_count,
+                               ELF::Word*       dynamic_flags);
+
+#endif /* LINKER_PHDR_H */