linker/linker_main.cpp

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *  * Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *  * Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in
  12  *    the documentation and/or other materials provided with the
  13  *    distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  18  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  19  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  21  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  22  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  23  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  25  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include "linker_main.h"
  30
  31 #include "linker_debug.h"
  32 #include "linker_cfi.h"
  33 #include "linker_gdb_support.h"
  34 #include "linker_globals.h"
  35 #include "linker_phdr.h"
  36 #include "linker_utils.h"
  37
  38 #include "private/bionic_globals.h"
  39 #include "private/bionic_tls.h"
  40 #include "private/KernelArgumentBlock.h"
  41
  42 #include "android-base/strings.h"
  43 #include "android-base/stringprintf.h"
  44 #ifdef __ANDROID__
  45 #include "debuggerd/handler.h"
  46 #endif
  47
  48 #include <async_safe/log.h>
  49
  50 #include <vector>
  51
  52 extern void __libc_init_globals(KernelArgumentBlock&);
  53 extern void __libc_init_AT_SECURE(KernelArgumentBlock&);
  54
  55 extern "C" void _start();
  56
  57 static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf);
  58
  59 // These should be preserved static to avoid emitting
  60 // RELATIVE relocations for the part of the code running
  61 // before linker links itself.
  62
  63 // TODO (dimtiry): remove somain, rename solist to solist_head
  64 static soinfo* solist;
  65 static soinfo* sonext;
  66 static soinfo* somain; // main process, always the one after libdl_info
  67
  68 void solist_add_soinfo(soinfo* si) {
  69   sonext->next = si;
  70   sonext = si;
  71 }
  72
  73 bool solist_remove_soinfo(soinfo* si) {
  74   soinfo *prev = nullptr, *trav;
  75   for (trav = solist; trav != nullptr; trav = trav->next) {
  76     if (trav == si) {
  77       break;
  78     }
  79     prev = trav;
  80   }
  81
  82   if (trav == nullptr) {
  83     // si was not in solist
  84     PRINT("name \"%s\"@%p is not in solist!", si->get_realpath(), si);
  85     return false;
  86   }
  87
  88   // prev will never be null, because the first entry in solist is
  89   // always the static libdl_info.
  90   CHECK(prev != nullptr);
  91   prev->next = si->next;
  92   if (si == sonext) {
  93     sonext = prev;
  94   }
  95
  96   return true;
  97 }
  98
  99 soinfo* solist_get_head() {
 100   return solist;
 101 }
 102
 103 soinfo* solist_get_somain() {
 104   return somain;
 105 }
 106
 107 int g_ld_debug_verbosity;
 108 abort_msg_t* g_abort_message = nullptr; // For debuggerd.
 109
 110 static std::vector<std::string> g_ld_preload_names;
 111
 112 static std::vector<soinfo*> g_ld_preloads;
 113
 114 static void parse_path(const char* path, const char* delimiters,
 115                        std::vector<std::string>* resolved_paths) {
 116   std::vector<std::string> paths;
 117   split_path(path, delimiters, &paths);
 118   resolve_paths(paths, resolved_paths);
 119 }
 120
 121 static void parse_LD_LIBRARY_PATH(const char* path) {
 122   std::vector<std::string> ld_libary_paths;
 123   parse_path(path, ":", &ld_libary_paths);
 124   g_default_namespace.set_ld_library_paths(std::move(ld_libary_paths));
 125 }
 126
 127 static void parse_LD_PRELOAD(const char* path) {
 128   g_ld_preload_names.clear();
 129   if (path != nullptr) {
 130     // We have historically supported ':' as well as ' ' in LD_PRELOAD.
 131     g_ld_preload_names = android::base::Split(path, " :");
 132     std::remove_if(g_ld_preload_names.begin(),
 133                    g_ld_preload_names.end(),
 134                    [] (const std::string& s) { return s.empty(); });
 135   }
 136 }
 137
 138 // An empty list of soinfos
 139 static soinfo_list_t g_empty_list;
 140
 141 static void add_vdso(KernelArgumentBlock& args) {
 142   ElfW(Ehdr)* ehdr_vdso = reinterpret_cast<ElfW(Ehdr)*>(args.getauxval(AT_SYSINFO_EHDR));
 143   if (ehdr_vdso == nullptr) {
 144     return;
 145   }
 146
 147   soinfo* si = soinfo_alloc(&g_default_namespace, "[vdso]", nullptr, 0, 0);
 148
 149   si->phdr = reinterpret_cast<ElfW(Phdr)*>(reinterpret_cast<char*>(ehdr_vdso) + ehdr_vdso->e_phoff);
 150   si->phnum = ehdr_vdso->e_phnum;
 151   si->base = reinterpret_cast<ElfW(Addr)>(ehdr_vdso);
 152   si->size = phdr_table_get_load_size(si->phdr, si->phnum);
 153   si->load_bias = get_elf_exec_load_bias(ehdr_vdso);
 154
 155   si->prelink_image();
 156   si->link_image(g_empty_list, soinfo_list_t::make_list(si), nullptr);
 157 }
 158
 159 /* gdb expects the linker to be in the debug shared object list.
 160  * Without this, gdb has trouble locating the linker's ".text"
 161  * and ".plt" sections. Gdb could also potentially use this to
 162  * relocate the offset of our exported 'rtld_db_dlactivity' symbol.
 163  * Note that the linker shouldn't be on the soinfo list.
 164  */
 165 static link_map linker_link_map;
 166
 167 static void init_linker_info_for_gdb(ElfW(Addr) linker_base, char* linker_path) {
 168   linker_link_map.l_addr = linker_base;
 169   linker_link_map.l_name = linker_path;
 170
 171   /*
 172    * Set the dynamic field in the link map otherwise gdb will complain with
 173    * the following:
 174    *   warning: .dynamic section for "/system/bin/linker" is not at the
 175    *   expected address (wrong library or version mismatch?)
 176    */
 177   ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_base);
 178   ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_base + elf_hdr->e_phoff);
 179   phdr_table_get_dynamic_section(phdr, elf_hdr->e_phnum, linker_base,
 180                                  &linker_link_map.l_ld, nullptr);
 181
 182 }
 183
 184 extern "C" int __system_properties_init(void);
 185
 186 static const char* get_executable_path() {
 187   static std::string executable_path;
 188   if (executable_path.empty()) {
 189     char path[PATH_MAX];
 190     ssize_t path_len = readlink("/proc/self/exe", path, sizeof(path));
 191     if (path_len == -1 || path_len >= static_cast<ssize_t>(sizeof(path))) {
 192       async_safe_fatal("readlink('/proc/self/exe') failed: %s", strerror(errno));
 193     }
 194     executable_path = std::string(path, path_len);
 195   }
 196
 197   return executable_path.c_str();
 198 }
 199
 200 #if defined(__LP64__)
 201 static char kLinkerPath[] = "/system/bin/linker64";
 202 #else
 203 static char kLinkerPath[] = "/system/bin/linker";
 204 #endif
 205
 206 /*
 207  * This code is called after the linker has linked itself and
 208  * fixed it's own GOT. It is safe to make references to externs
 209  * and other non-local data at this point.
 210  */
 211 static ElfW(Addr) __linker_init_post_relocation(KernelArgumentBlock& args) {
 212   ProtectedDataGuard guard;
 213
 214 #if TIMING
 215   struct timeval t0, t1;
 216   gettimeofday(&t0, 0);
 217 #endif
 218
 219   // Sanitize the environment.
 220   __libc_init_AT_SECURE(args);
 221
 222   // Initialize system properties
 223   __system_properties_init(); // may use 'environ'
 224
 225   // Register the debuggerd signal handler.
 226 #ifdef __ANDROID__
 227   debuggerd_callbacks_t callbacks = {
 228     .get_abort_message = []() {
 229       return g_abort_message;
 230     },
 231     .post_dump = &notify_gdb_of_libraries,
 232   };
 233   debuggerd_init(&callbacks);
 234 #endif
 235
 236   g_linker_logger.ResetState();
 237
 238   // Get a few environment variables.
 239   const char* LD_DEBUG = getenv("LD_DEBUG");
 240   if (LD_DEBUG != nullptr) {
 241     g_ld_debug_verbosity = atoi(LD_DEBUG);
 242   }
 243
 244 #if defined(__LP64__)
 245   INFO("[ Android dynamic linker (64-bit) ]");
 246 #else
 247   INFO("[ Android dynamic linker (32-bit) ]");
 248 #endif
 249
 250   // These should have been sanitized by __libc_init_AT_SECURE, but the test
 251   // doesn't cost us anything.
 252   const char* ldpath_env = nullptr;
 253   const char* ldpreload_env = nullptr;
 254   if (!getauxval(AT_SECURE)) {
 255     ldpath_env = getenv("LD_LIBRARY_PATH");
 256     if (ldpath_env != nullptr) {
 257       INFO("[ LD_LIBRARY_PATH set to \"%s\" ]", ldpath_env);
 258     }
 259     ldpreload_env = getenv("LD_PRELOAD");
 260     if (ldpreload_env != nullptr) {
 261       INFO("[ LD_PRELOAD set to \"%s\" ]", ldpreload_env);
 262     }
 263   }
 264
 265   struct stat file_stat;
 266   // Stat "/proc/self/exe" instead of executable_path because
 267   // the executable could be unlinked by this point and it should
 268   // not cause a crash (see http://b/31084669)
 269   if (TEMP_FAILURE_RETRY(stat("/proc/self/exe", &file_stat)) != 0) {
 270     async_safe_fatal("unable to stat \"/proc/self/exe\": %s", strerror(errno));
 271   }
 272
 273   const char* executable_path = get_executable_path();
 274   soinfo* si = soinfo_alloc(&g_default_namespace, executable_path, &file_stat, 0, RTLD_GLOBAL);
 275   if (si == nullptr) {
 276     async_safe_fatal("Couldn't allocate soinfo: out of memory?");
 277   }
 278
 279   /* bootstrap the link map, the main exe always needs to be first */
 280   si->set_main_executable();
 281   link_map* map = &(si->link_map_head);
 282
 283   // Register the main executable and the linker upfront to have
 284   // gdb aware of them before loading the rest of the dependency
 285   // tree.
 286   map->l_addr = 0;
 287   map->l_name = const_cast<char*>(executable_path);
 288   insert_link_map_into_debug_map(map);
 289   insert_link_map_into_debug_map(&linker_link_map);
 290
 291   // Extract information passed from the kernel.
 292   si->phdr = reinterpret_cast<ElfW(Phdr)*>(args.getauxval(AT_PHDR));
 293   si->phnum = args.getauxval(AT_PHNUM);
 294
 295   /* Compute the value of si->base. We can't rely on the fact that
 296    * the first entry is the PHDR because this will not be true
 297    * for certain executables (e.g. some in the NDK unit test suite)
 298    */
 299   si->base = 0;
 300   si->size = phdr_table_get_load_size(si->phdr, si->phnum);
 301   si->load_bias = 0;
 302   for (size_t i = 0; i < si->phnum; ++i) {
 303     if (si->phdr[i].p_type == PT_PHDR) {
 304       si->load_bias = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_vaddr;
 305       si->base = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_offset;
 306       break;
 307     }
 308   }
 309
 310   if (si->base == 0) {
 311     async_safe_fatal("Could not find a PHDR: broken executable?");
 312   }
 313
 314   si->dynamic = nullptr;
 315
 316   ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(si->base);
 317
 318   // We haven't supported non-PIE since Lollipop for security reasons.
 319   if (elf_hdr->e_type != ET_DYN) {
 320     // We don't use __libc_fatal here because we don't want a tombstone: it's
 321     // been several years now but we still find ourselves on app compatibility
 322     // investigations because some app's trying to launch an executable that
 323     // hasn't worked in at least three years, and we've "helpfully" dropped a
 324     // tombstone for them. The tombstone never provided any detail relevant to
 325     // fixing the problem anyway, and the utility of drawing extra attention
 326     // to the problem is non-existent at this late date.
 327     async_safe_format_fd(STDERR_FILENO,
 328                      "\"%s\": error: Android 5.0 and later only support "
 329                      "position-independent executables (-fPIE).\n",
 330                      g_argv[0]);
 331     exit(EXIT_FAILURE);
 332   }
 333
 334   // Use LD_LIBRARY_PATH and LD_PRELOAD (but only if we aren't setuid/setgid).
 335   parse_LD_LIBRARY_PATH(ldpath_env);
 336   parse_LD_PRELOAD(ldpreload_env);
 337
 338   somain = si;
 339
 340   init_default_namespace(executable_path);
 341
 342   if (!si->prelink_image()) {
 343     async_safe_fatal("CANNOT LINK EXECUTABLE \"%s\": %s", g_argv[0], linker_get_error_buffer());
 344   }
 345
 346   // add somain to global group
 347   si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL);
 348
 349   // Load ld_preloads and dependencies.
 350   std::vector<const char*> needed_library_name_list;
 351   size_t ld_preloads_count = 0;
 352
 353   for (const auto& ld_preload_name : g_ld_preload_names) {
 354     needed_library_name_list.push_back(ld_preload_name.c_str());
 355     ++ld_preloads_count;
 356   }
 357
 358   for_each_dt_needed(si, [&](const char* name) {
 359     needed_library_name_list.push_back(name);
 360   });
 361
 362   const char** needed_library_names = &needed_library_name_list[0];
 363   size_t needed_libraries_count = needed_library_name_list.size();
 364
 365   if (needed_libraries_count > 0 &&
 366       !find_libraries(&g_default_namespace,
 367                       si,
 368                       needed_library_names,
 369                       needed_libraries_count,
 370                       nullptr,
 371                       &g_ld_preloads,
 372                       ld_preloads_count,
 373                       RTLD_GLOBAL,
 374                       nullptr,
 375                       true /* add_as_children */,
 376                       true /* search_linked_namespaces */)) {
 377     async_safe_fatal("CANNOT LINK EXECUTABLE \"%s\": %s", g_argv[0], linker_get_error_buffer());
 378   } else if (needed_libraries_count == 0) {
 379     if (!si->link_image(g_empty_list, soinfo_list_t::make_list(si), nullptr)) {
 380       async_safe_fatal("CANNOT LINK EXECUTABLE \"%s\": %s", g_argv[0], linker_get_error_buffer());
 381     }
 382     si->increment_ref_count();
 383   }
 384
 385   add_vdso(args);
 386
 387   if (!get_cfi_shadow()->InitialLinkDone(solist)) {
 388     async_safe_fatal("CANNOT LINK EXECUTABLE \"%s\": %s", g_argv[0], linker_get_error_buffer());
 389   }
 390
 391   si->call_pre_init_constructors();
 392
 393   /* After the prelink_image, the si->load_bias is initialized.
 394    * For so lib, the map->l_addr will be updated in notify_gdb_of_load.
 395    * We need to update this value for so exe here. So Unwind_Backtrace
 396    * for some arch like x86 could work correctly within so exe.
 397    */
 398   map->l_addr = si->load_bias;
 399   si->call_constructors();
 400
 401 #if TIMING
 402   gettimeofday(&t1, nullptr);
 403   PRINT("LINKER TIME: %s: %d microseconds", g_argv[0], (int) (
 404            (((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) -
 405            (((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec)));
 406 #endif
 407 #if STATS
 408   PRINT("RELO STATS: %s: %d abs, %d rel, %d copy, %d symbol", g_argv[0],
 409          linker_stats.count[kRelocAbsolute],
 410          linker_stats.count[kRelocRelative],
 411          linker_stats.count[kRelocCopy],
 412          linker_stats.count[kRelocSymbol]);
 413 #endif
 414 #if COUNT_PAGES
 415   {
 416     unsigned n;
 417     unsigned i;
 418     unsigned count = 0;
 419     for (n = 0; n < 4096; n++) {
 420       if (bitmask[n]) {
 421         unsigned x = bitmask[n];
 422 #if defined(__LP64__)
 423         for (i = 0; i < 32; i++) {
 424 #else
 425         for (i = 0; i < 8; i++) {
 426 #endif
 427           if (x & 1) {
 428             count++;
 429           }
 430           x >>= 1;
 431         }
 432       }
 433     }
 434     PRINT("PAGES MODIFIED: %s: %d (%dKB)", g_argv[0], count, count * 4);
 435   }
 436 #endif
 437
 438 #if TIMING || STATS || COUNT_PAGES
 439   fflush(stdout);
 440 #endif
 441
 442   ElfW(Addr) entry = args.getauxval(AT_ENTRY);
 443   TRACE("[ Ready to execute \"%s\" @ %p ]", si->get_realpath(), reinterpret_cast<void*>(entry));
 444   return entry;
 445 }
 446
 447 /* Compute the load-bias of an existing executable. This shall only
 448  * be used to compute the load bias of an executable or shared library
 449  * that was loaded by the kernel itself.
 450  *
 451  * Input:
 452  *    elf    -> address of ELF header, assumed to be at the start of the file.
 453  * Return:
 454  *    load bias, i.e. add the value of any p_vaddr in the file to get
 455  *    the corresponding address in memory.
 456  */
 457 static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf) {
 458   ElfW(Addr) offset = elf->e_phoff;
 459   const ElfW(Phdr)* phdr_table =
 460       reinterpret_cast<const ElfW(Phdr)*>(reinterpret_cast<uintptr_t>(elf) + offset);
 461   const ElfW(Phdr)* phdr_end = phdr_table + elf->e_phnum;
 462
 463   for (const ElfW(Phdr)* phdr = phdr_table; phdr < phdr_end; phdr++) {
 464     if (phdr->p_type == PT_LOAD) {
 465       return reinterpret_cast<ElfW(Addr)>(elf) + phdr->p_offset - phdr->p_vaddr;
 466     }
 467   }
 468   return 0;
 469 }
 470
 471 static void __linker_cannot_link(const char* argv0) {
 472   async_safe_fatal("CANNOT LINK EXECUTABLE \"%s\": %s", argv0, linker_get_error_buffer());
 473 }
 474
 475 /*
 476  * This is the entry point for the linker, called from begin.S. This
 477  * method is responsible for fixing the linker's own relocations, and
 478  * then calling __linker_init_post_relocation().
 479  *
 480  * Because this method is called before the linker has fixed it's own
 481  * relocations, any attempt to reference an extern variable, extern
 482  * function, or other GOT reference will generate a segfault.
 483  */
 484 extern "C" ElfW(Addr) __linker_init(void* raw_args) {
 485   KernelArgumentBlock args(raw_args);
 486
 487   // AT_BASE is set to 0 in the case when linker is run by iself
 488   // so in order to link the linker it needs to calcuate AT_BASE
 489   // using information at hand. The trick below takes advantage
 490   // of the fact that the value of linktime_addr before relocations
 491   // are run is an offset and this can be used to calculate AT_BASE.
 492   static uintptr_t linktime_addr = reinterpret_cast<uintptr_t>(&linktime_addr);
 493   ElfW(Addr) linker_addr = reinterpret_cast<uintptr_t>(&linktime_addr) - linktime_addr;
 494
 495 #if defined(__clang_analyzer__)
 496   // The analyzer assumes that linker_addr will always be null. Make it an
 497   // unknown value so we don't have to mark N places with NOLINTs.
 498   //
 499   // (`+=`, rather than `=`, allows us to sidestep a potential "unused store"
 500   // complaint)
 501   linker_addr += reinterpret_cast<uintptr_t>(raw_args);
 502 #endif
 503
 504   ElfW(Addr) entry_point = args.getauxval(AT_ENTRY);
 505   ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_addr);
 506   ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_addr + elf_hdr->e_phoff);
 507
 508   soinfo linker_so(nullptr, nullptr, nullptr, 0, 0);
 509
 510   linker_so.base = linker_addr;
 511   linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum);
 512   linker_so.load_bias = get_elf_exec_load_bias(elf_hdr);
 513   linker_so.dynamic = nullptr;
 514   linker_so.phdr = phdr;
 515   linker_so.phnum = elf_hdr->e_phnum;
 516   linker_so.set_linker_flag();
 517
 518   // Prelink the linker so we can access linker globals.
 519   if (!linker_so.prelink_image()) __linker_cannot_link(args.argv[0]);
 520
 521   // This might not be obvious... The reasons why we pass g_empty_list
 522   // in place of local_group here are (1) we do not really need it, because
 523   // linker is built with DT_SYMBOLIC and therefore relocates its symbols against
 524   // itself without having to look into local_group and (2) allocators
 525   // are not yet initialized, and therefore we cannot use linked_list.push_*
 526   // functions at this point.
 527   if (!linker_so.link_image(g_empty_list, g_empty_list, nullptr)) __linker_cannot_link(args.argv[0]);
 528
 529 #if defined(__i386__)
 530   // On x86, we can't make system calls before this point.
 531   // We can't move this up because this needs to assign to a global.
 532   // Note that until we call __libc_init_main_thread below we have
 533   // no TLS, so you shouldn't make a system call that can fail, because
 534   // it will SEGV when it tries to set errno.
 535   __libc_init_sysinfo(args);
 536 #endif
 537
 538   // Initialize the main thread (including TLS, so system calls really work).
 539   __libc_init_main_thread(args);
 540
 541   // We didn't protect the linker's RELRO pages in link_image because we
 542   // couldn't make system calls on x86 at that point, but we can now...
 543   if (!linker_so.protect_relro()) __linker_cannot_link(args.argv[0]);
 544
 545   // Initialize the linker's static libc's globals
 546   __libc_init_globals(args);
 547
 548   // store argc/argv/envp to use them for calling constructors
 549   g_argc = args.argc;
 550   g_argv = args.argv;
 551   g_envp = args.envp;
 552
 553   // Initialize the linker's own global variables
 554   linker_so.call_constructors();
 555
 556   // If the linker is not acting as PT_INTERP entry_point is equal to
 557   // _start. Which means that the linker is running as an executable and
 558   // already linked by PT_INTERP.
 559   //
 560   // This happens when user tries to run 'adb shell /system/bin/linker'
 561   // see also https://code.google.com/p/android/issues/detail?id=63174
 562   if (reinterpret_cast<ElfW(Addr)>(&_start) == entry_point) {
 563     async_safe_format_fd(STDOUT_FILENO,
 564                      "This is %s, the helper program for dynamic executables.\n",
 565                      args.argv[0]);
 566     exit(0);
 567   }
 568
 569   init_linker_info_for_gdb(linker_addr, kLinkerPath);
 570
 571   // Initialize static variables. Note that in order to
 572   // get correct libdl_info we need to call constructors
 573   // before get_libdl_info().
 574   sonext = solist = get_libdl_info(kLinkerPath, linker_link_map);
 575   g_default_namespace.add_soinfo(solist);
 576
 577   // We have successfully fixed our own relocations. It's safe to run
 578   // the main part of the linker now.
 579   args.abort_message_ptr = &g_abort_message;
 580   ElfW(Addr) start_address = __linker_init_post_relocation(args);
 581
 582   INFO("[ Jumping to _start (%p)... ]", reinterpret_cast<void*>(start_address));
 583
 584   // Return the address that the calling assembly stub should jump to.
 585   return start_address;
 586 }