2002-08-25 Roland McGrath <roland@redhat.com>
[kopensolaris-gnu/glibc.git] / elf / rtld.c
1 /* Run time dynamic linker.
2    Copyright (C) 1995-1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <errno.h>
21 #include <fcntl.h>
22 #include <stdbool.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <sys/mman.h>           /* Check if MAP_ANON is defined.  */
27 #include <sys/param.h>
28 #include <sys/stat.h>
29 #include <ldsodefs.h>
30 #include <stdio-common/_itoa.h>
31 #include <entry.h>
32 #include <fpu_control.h>
33 #include <hp-timing.h>
34 #include <bits/libc-lock.h>
35 #include "dynamic-link.h"
36 #include "dl-librecon.h"
37 #include <unsecvars.h>
38 #include <dl-cache.h>
39 #include <dl-procinfo.h>
40
41 #include <assert.h>
42
43 /* Avoid PLT use for our local calls at startup.  */
44 extern __typeof (__mempcpy) __mempcpy attribute_hidden;
45
46 /* GCC has mental blocks about _exit.  */
47 extern __typeof (_exit) exit_internal asm ("_exit") attribute_hidden;
48 #define _exit exit_internal
49
50 /* Helper function to handle errors while resolving symbols.  */
51 static void print_unresolved (int errcode, const char *objname,
52                               const char *errsting);
53
54 /* Helper function to handle errors when a version is missing.  */
55 static void print_missing_version (int errcode, const char *objname,
56                                    const char *errsting);
57
58 /* Print the various times we collected.  */
59 static void print_statistics (void);
60
61 /* This is a list of all the modes the dynamic loader can be in.  */
62 enum mode { normal, list, verify, trace };
63
64 /* Process all environments variables the dynamic linker must recognize.
65    Since all of them start with `LD_' we are a bit smarter while finding
66    all the entries.  */
67 static void process_envvars (enum mode *modep);
68
69 int _dl_argc attribute_hidden;
70 char **_dl_argv = NULL;
71 INTDEF(_dl_argv)
72
73 /* Nonzero if we were run directly.  */
74 unsigned int _dl_skip_args attribute_hidden;
75
76 /* Set nonzero during loading and initialization of executable and
77    libraries, cleared before the executable's entry point runs.  This
78    must not be initialized to nonzero, because the unused dynamic
79    linker loaded in for libc.so's "ld.so.1" dep will provide the
80    definition seen by libc.so's initializer; that value must be zero,
81    and will be since that dynamic linker's _dl_start and dl_main will
82    never be called.  */
83 int _dl_starting_up = 0;
84 INTVARDEF(_dl_starting_up)
85
86 /* This is the structure which defines all variables global to ld.so
87    (except those which cannot be added for some reason).  */
88 struct rtld_global _rtld_global =
89   {
90     /* Get architecture specific initializer.  */
91 #include <dl-procinfo.c>
92     ._dl_debug_fd = STDERR_FILENO,
93 #if 1
94     /* XXX I know about at least one case where we depend on the old
95        weak behavior (it has to do with librt).  Until we get DSO
96        groups implemented we have to make this the default.
97        Bummer. --drepper  */
98     ._dl_dynamic_weak = 1,
99 #endif
100     ._dl_lazy = 1,
101     ._dl_fpu_control = _FPU_DEFAULT,
102     ._dl_correct_cache_id = _DL_CACHE_DEFAULT_ID,
103     ._dl_hwcap_mask = HWCAP_IMPORTANT,
104     ._dl_load_lock = _LIBC_LOCK_RECURSIVE_INITIALIZER
105   };
106 strong_alias (_rtld_global, _rtld_local);
107
108 static void dl_main (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
109                      ElfW(Addr) *user_entry);
110
111 static struct libname_list _dl_rtld_libname;
112 static struct libname_list _dl_rtld_libname2;
113
114 /* We expect less than a second for relocation.  */
115 #ifdef HP_SMALL_TIMING_AVAIL
116 # undef HP_TIMING_AVAIL
117 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
118 #endif
119
120 /* Variable for statistics.  */
121 #ifndef HP_TIMING_NONAVAIL
122 static hp_timing_t rtld_total_time;
123 static hp_timing_t relocate_time;
124 static hp_timing_t load_time;
125 static hp_timing_t start_time;
126 #endif
127
128 /* Additional definitions needed by TLS initialization.  */
129 #ifdef TLS_INIT_HELPER
130 TLS_INIT_HELPER
131 #endif
132
133 /* Before ld.so is relocated we must not access variables which need
134    relocations.  This means variables which are exported.  Variables
135    declared as static are fine.  If we can mark a variable hidden this
136    is fine, too.  The latter is impotant here.  We can avoid setting
137    up a temporary link map for ld.so if we can mark _rtld_global as
138    hidden.  */
139 #if defined PI_STATIC_AND_HIDDEN && defined HAVE_HIDDEN \
140     && defined HAVE_VISIBILITY_ATTRIBUTE
141 # define DONT_USE_BOOTSTRAP_MAP 1
142 #endif
143
144 #ifdef DONT_USE_BOOTSTRAP_MAP
145 static ElfW(Addr) _dl_start_final (void *arg);
146 #else
147 static ElfW(Addr) _dl_start_final (void *arg,
148                                    struct link_map *bootstrap_map_p);
149 #endif
150
151 #ifdef RTLD_START
152 RTLD_START
153 #else
154 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
155 #endif
156
157 #ifndef VALIDX
158 # define VALIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
159                       + DT_EXTRANUM + DT_VALTAGIDX (tag))
160 #endif
161 #ifndef ADDRIDX
162 # define ADDRIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
163                        + DT_EXTRANUM + DT_VALNUM + DT_ADDRTAGIDX (tag))
164 #endif
165
166 /* This is the second half of _dl_start (below).  It can be inlined safely
167    under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
168    references.  When the tools don't permit us to avoid using a GOT entry
169    for _dl_rtld_global (no attribute_hidden support), we must make sure
170    this function is not inlined (see below).  */
171
172 #ifdef DONT_USE_BOOTSTRAP_MAP
173 static inline ElfW(Addr) __attribute__ ((always_inline))
174 _dl_start_final (void *arg)
175 #else
176 static ElfW(Addr) __attribute__ ((noinline))
177 _dl_start_final (void *arg, struct link_map *bootstrap_map_p)
178 #endif
179 {
180   ElfW(Addr) start_addr;
181   extern char _begin[] attribute_hidden;
182   extern char _end[] attribute_hidden;
183
184   if (HP_TIMING_AVAIL)
185     {
186       /* If it hasn't happen yet record the startup time.  */
187       if (! HP_TIMING_INLINE)
188         HP_TIMING_NOW (start_time);
189
190       /* Initialize the timing functions.  */
191       HP_TIMING_DIFF_INIT ();
192     }
193
194   /* Transfer data about ourselves to the permanent link_map structure.  */
195 #ifndef DONT_USE_BOOTSTRAP_MAP
196   GL(dl_rtld_map).l_addr = bootstrap_map_p->l_addr;
197   GL(dl_rtld_map).l_ld = bootstrap_map_p->l_ld;
198   memcpy (GL(dl_rtld_map).l_info, bootstrap_map_p->l_info,
199           sizeof GL(dl_rtld_map).l_info);
200   GL(dl_rtld_map).l_mach = bootstrap_map_p->l_mach;
201 #endif
202   _dl_setup_hash (&GL(dl_rtld_map));
203   GL(dl_rtld_map).l_opencount = 1;
204   GL(dl_rtld_map).l_map_start = (ElfW(Addr)) _begin;
205   GL(dl_rtld_map).l_map_end = (ElfW(Addr)) _end;
206   /* Copy the TLS related data if necessary.  */
207 #if USE_TLS && !defined DONT_USE_BOOTSTRAP_MAP
208 # ifdef HAVE___THREAD
209   assert (bootstrap_map_p->l_tls_modid != 0);
210 # else
211   if (bootstrap_map_p->l_tls_modid != 0)
212 # endif
213     {
214       GL(dl_rtld_map).l_tls_blocksize = bootstrap_map_p->l_tls_blocksize;
215       GL(dl_rtld_map).l_tls_align = bootstrap_map_p->l_tls_align;
216       GL(dl_rtld_map).l_tls_initimage_size
217         = bootstrap_map_p->l_tls_initimage_size;
218       GL(dl_rtld_map).l_tls_initimage = bootstrap_map_p->l_tls_initimage;
219       GL(dl_rtld_map).l_tls_offset = bootstrap_map_p->l_tls_offset;
220       GL(dl_rtld_map).l_tls_modid = 1;
221       GL(dl_rtld_map).l_tls_tp_initialized
222         = bootstrap_map_p->l_tls_tp_initialized;
223     }
224 #endif
225
226 #if HP_TIMING_AVAIL
227   HP_TIMING_NOW (GL(dl_cpuclock_offset));
228 #endif
229
230   /* Call the OS-dependent function to set up life so we can do things like
231      file access.  It will call `dl_main' (below) to do all the real work
232      of the dynamic linker, and then unwind our frame and run the user
233      entry point on the same stack we entered on.  */
234   start_addr =  _dl_sysdep_start (arg, &dl_main);
235
236 #ifndef HP_TIMING_NONAVAIL
237   if (HP_TIMING_AVAIL)
238     {
239       hp_timing_t end_time;
240
241       /* Get the current time.  */
242       HP_TIMING_NOW (end_time);
243
244       /* Compute the difference.  */
245       HP_TIMING_DIFF (rtld_total_time, start_time, end_time);
246     }
247 #endif
248
249   if (__builtin_expect (GL(dl_debug_mask) & DL_DEBUG_STATISTICS, 0))
250     print_statistics ();
251
252   return start_addr;
253 }
254
255 static ElfW(Addr) __attribute_used__ internal_function
256 _dl_start (void *arg)
257 {
258 #ifdef DONT_USE_BOOTSTRAP_MAP
259 # define bootstrap_map GL(dl_rtld_map)
260 #else
261   struct link_map bootstrap_map;
262 #endif
263 #if !defined HAVE_BUILTIN_MEMSET || defined USE_TLS
264   size_t cnt;
265 #endif
266 #ifdef USE_TLS
267   ElfW(Ehdr) *ehdr;
268   ElfW(Phdr) *phdr;
269   dtv_t initdtv[3];
270 #endif
271
272   /* This #define produces dynamic linking inline functions for
273      bootstrap relocation instead of general-purpose relocation.  */
274 #define RTLD_BOOTSTRAP
275 #define RESOLVE_MAP(sym, version, flags) \
276   ((*(sym))->st_shndx == SHN_UNDEF ? 0 : &bootstrap_map)
277 #define RESOLVE(sym, version, flags) \
278   ((*(sym))->st_shndx == SHN_UNDEF ? 0 : bootstrap_map.l_addr)
279 #include "dynamic-link.h"
280
281   if (HP_TIMING_INLINE && HP_TIMING_AVAIL)
282     HP_TIMING_NOW (start_time);
283
284   /* Partly clean the `bootstrap_map' structure up.  Don't use
285      `memset' since it might not be built in or inlined and we cannot
286      make function calls at this point.  Use '__builtin_memset' if we
287      know it is available.  We do not have to clear the memory if we
288      do not have to use the temporary bootstrap_map.  Global variables
289      are initialized to zero by default.  */
290 #ifndef DONT_USE_BOOTSTRAP_MAP
291 # ifdef HAVE_BUILTIN_MEMSET
292   __builtin_memset (bootstrap_map.l_info, '\0', sizeof (bootstrap_map.l_info));
293 # else
294   for (cnt = 0;
295        cnt < sizeof (bootstrap_map.l_info) / sizeof (bootstrap_map.l_info[0]);
296        ++cnt)
297     bootstrap_map.l_info[cnt] = 0;
298 # endif
299 #endif
300
301   /* Figure out the run-time load address of the dynamic linker itself.  */
302   bootstrap_map.l_addr = elf_machine_load_address ();
303
304   /* Read our own dynamic section and fill in the info array.  */
305   bootstrap_map.l_ld = (void *) bootstrap_map.l_addr + elf_machine_dynamic ();
306   elf_get_dynamic_info (&bootstrap_map);
307
308 #if USE_TLS
309 # if !defined HAVE___THREAD && !defined DONT_USE_BOOTSTRAP_MAP
310   /* Signal that we have not found TLS data so far.  */
311   bootstrap_map.l_tls_modid = 0;
312 # endif
313
314   /* Get the dynamic linkers program header.  */
315   ehdr = (ElfW(Ehdr) *) bootstrap_map.l_addr;
316   phdr = (ElfW(Phdr) *) (bootstrap_map.l_addr + ehdr->e_phoff);
317   for (cnt = 0; cnt < ehdr->e_phnum; ++cnt)
318     if (phdr[cnt].p_type == PT_TLS)
319       {
320         void *tlsblock;
321         size_t max_align = MAX (TLS_INIT_TCB_ALIGN, phdr[cnt].p_align);
322         char *p;
323
324         bootstrap_map.l_tls_blocksize = phdr[cnt].p_memsz;
325         bootstrap_map.l_tls_align = phdr[cnt].p_align;
326         assert (bootstrap_map.l_tls_blocksize != 0);
327         bootstrap_map.l_tls_initimage_size = phdr[cnt].p_filesz;
328         bootstrap_map.l_tls_initimage = (void *) (bootstrap_map.l_addr
329                                                   + phdr[cnt].p_vaddr);
330
331         /* We can now allocate the initial TLS block.  This can happen
332            on the stack.  We'll get the final memory later when we
333            know all about the various objects loaded at startup
334            time.  */
335 # if TLS_TCB_AT_TP
336         tlsblock = alloca (roundup (bootstrap_map.l_tls_blocksize,
337                                     TLS_INIT_TCB_ALIGN)
338                            + TLS_INIT_TCB_SIZE
339                            + max_align);
340 # elif TLS_DTV_AT_TP
341         tlsblock = alloca (roundup (TLS_INIT_TCB_SIZE,
342                                     bootstrap_map.l_tls_align)
343                            + bootstrap_map.l_tls_blocksize
344                            + max_align);
345 # else
346         /* In case a model with a different layout for the TCB and DTV
347            is defined add another #elif here and in the following #ifs.  */
348 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
349 # endif
350         /* Align the TLS block.  */
351         tlsblock = (void *) (((uintptr_t) tlsblock + max_align - 1)
352                              & ~(max_align - 1));
353
354         /* Initialize the dtv.  [0] is the length, [1] the generation
355            counter.  */
356         initdtv[0].counter = 1;
357         initdtv[1].counter = 0;
358
359         /* Initialize the TLS block.  */
360 # if TLS_TCB_AT_TP
361         initdtv[2].pointer = tlsblock;
362 # elif TLS_DTV_AT_TP
363         bootstrap_map.l_tls_offset = roundup (TLS_INIT_TCB_SIZE,
364                                               bootstrap_map.l_tls_align);
365         initdtv[2].pointer = (char *) tlsblock + bootstrap_map.l_tls_offset;
366 # else
367 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
368 # endif
369         p = __mempcpy (initdtv[2].pointer, bootstrap_map.l_tls_initimage,
370                        bootstrap_map.l_tls_initimage_size);
371 # ifdef HAVE_BUILTIN_MEMSET
372         __builtin_memset (p, '\0', (bootstrap_map.l_tls_blocksize
373                                     - bootstrap_map.l_tls_initimage_size));
374 # else
375         {
376           size_t remaining = (bootstrap_map.l_tls_blocksize
377                               - bootstrap_map.l_tls_initimage_size);
378           while (remaining-- > 0)
379             *p++ = '\0';
380         }
381 #endif
382
383         /* Install the pointer to the dtv.  */
384
385         /* Initialize the thread pointer.  */
386 # if TLS_TCB_AT_TP
387         bootstrap_map.l_tls_offset
388           = roundup (bootstrap_map.l_tls_blocksize, TLS_INIT_TCB_ALIGN);
389
390         INSTALL_DTV ((char *) tlsblock + bootstrap_map.l_tls_offset,
391                      initdtv);
392
393         if (TLS_INIT_TP ((char *) tlsblock + bootstrap_map.l_tls_offset, 0)
394             != 0)
395           _dl_fatal_printf ("cannot setup thread-local storage\n");
396 # elif TLS_DTV_AT_TP
397         INSTALL_DTV (tlsblock, initdtv);
398         if (TLS_INIT_TP (tlsblock, 0) != 0)
399           _dl_fatal_printf ("cannot setup thread-local storage\n");
400 # else
401 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
402 # endif
403
404         /* So far this is module number one.  */
405         bootstrap_map.l_tls_modid = 1;
406         /* The TP got initialized.  */
407         bootstrap_map.l_tls_tp_initialized = 1;
408
409         /* There can only be one PT_TLS entry.  */
410         break;
411       }
412 #endif  /* use TLS */
413
414 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
415   ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
416 #endif
417
418   if (bootstrap_map.l_addr || ! bootstrap_map.l_info[VALIDX(DT_GNU_PRELINKED)])
419     {
420       /* Relocate ourselves so we can do normal function calls and
421          data access using the global offset table.  */
422
423       ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, 0);
424     }
425
426   /* Please note that we don't allow profiling of this object and
427      therefore need not test whether we have to allocate the array
428      for the relocation results (as done in dl-reloc.c).  */
429
430   /* Now life is sane; we can call functions and access global data.
431      Set up to use the operating system facilities, and find out from
432      the operating system's program loader where to find the program
433      header table in core.  Put the rest of _dl_start into a separate
434      function, that way the compiler cannot put accesses to the GOT
435      before ELF_DYNAMIC_RELOCATE.  */
436   {
437 #ifdef DONT_USE_BOOTSTRAP_MAP
438     ElfW(Addr) entry = _dl_start_final (arg);
439 #else
440     ElfW(Addr) entry = _dl_start_final (arg, &bootstrap_map);
441 #endif
442
443 #ifndef ELF_MACHINE_START_ADDRESS
444 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
445 #endif
446
447     return ELF_MACHINE_START_ADDRESS (GL(dl_loaded), entry);
448   }
449 }
450
451
452
453 /* Now life is peachy; we can do all normal operations.
454    On to the real work.  */
455
456 /* Some helper functions.  */
457
458 /* Arguments to relocate_doit.  */
459 struct relocate_args
460 {
461   struct link_map *l;
462   int lazy;
463 };
464
465 struct map_args
466 {
467   /* Argument to map_doit.  */
468   char *str;
469   /* Return value of map_doit.  */
470   struct link_map *main_map;
471 };
472
473 /* Arguments to version_check_doit.  */
474 struct version_check_args
475 {
476   int doexit;
477   int dotrace;
478 };
479
480 static void
481 relocate_doit (void *a)
482 {
483   struct relocate_args *args = (struct relocate_args *) a;
484
485   INTUSE(_dl_relocate_object) (args->l, args->l->l_scope, args->lazy, 0);
486 }
487
488 static void
489 map_doit (void *a)
490 {
491   struct map_args *args = (struct map_args *) a;
492   args->main_map = INTUSE(_dl_map_object) (NULL, args->str, 0, lt_library, 0, 0);
493 }
494
495 static void
496 version_check_doit (void *a)
497 {
498   struct version_check_args *args = (struct version_check_args *) a;
499   if (_dl_check_all_versions (GL(dl_loaded), 1, args->dotrace) && args->doexit)
500     /* We cannot start the application.  Abort now.  */
501     _exit (1);
502 }
503
504
505 static inline struct link_map *
506 find_needed (const char *name)
507 {
508   unsigned int n = GL(dl_loaded)->l_searchlist.r_nlist;
509
510   while (n-- > 0)
511     if (_dl_name_match_p (name, GL(dl_loaded)->l_searchlist.r_list[n]))
512       return GL(dl_loaded)->l_searchlist.r_list[n];
513
514   /* Should never happen.  */
515   return NULL;
516 }
517
518 static int
519 match_version (const char *string, struct link_map *map)
520 {
521   const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
522   ElfW(Verdef) *def;
523
524 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
525   if (map->l_info[VERDEFTAG] == NULL)
526     /* The file has no symbol versioning.  */
527     return 0;
528
529   def = (ElfW(Verdef) *) ((char *) map->l_addr
530                           + map->l_info[VERDEFTAG]->d_un.d_ptr);
531   while (1)
532     {
533       ElfW(Verdaux) *aux = (ElfW(Verdaux) *) ((char *) def + def->vd_aux);
534
535       /* Compare the version strings.  */
536       if (strcmp (string, strtab + aux->vda_name) == 0)
537         /* Bingo!  */
538         return 1;
539
540       /* If no more definitions we failed to find what we want.  */
541       if (def->vd_next == 0)
542         break;
543
544       /* Next definition.  */
545       def = (ElfW(Verdef) *) ((char *) def + def->vd_next);
546     }
547
548   return 0;
549 }
550
551 static const char *library_path;        /* The library search path.  */
552 static const char *preloadlist;         /* The list preloaded objects.  */
553 static int version_info;                /* Nonzero if information about
554                                            versions has to be printed.  */
555
556 static void
557 dl_main (const ElfW(Phdr) *phdr,
558          ElfW(Word) phnum,
559          ElfW(Addr) *user_entry)
560 {
561   const ElfW(Phdr) *ph;
562   enum mode mode;
563   struct link_map **preloads;
564   unsigned int npreloads;
565   size_t file_size;
566   char *file;
567   bool has_interp = false;
568   unsigned int i;
569   bool prelinked = false;
570   bool rtld_is_main = false;
571 #ifndef HP_TIMING_NONAVAIL
572   hp_timing_t start;
573   hp_timing_t stop;
574   hp_timing_t diff;
575 #endif
576 #ifdef USE_TLS
577   void *tcbp;
578 #endif
579
580   /* Process the environment variable which control the behaviour.  */
581   process_envvars (&mode);
582
583   /* Set up a flag which tells we are just starting.  */
584   INTUSE(_dl_starting_up) = 1;
585
586   if (*user_entry == (ElfW(Addr)) ENTRY_POINT)
587     {
588       /* Ho ho.  We are not the program interpreter!  We are the program
589          itself!  This means someone ran ld.so as a command.  Well, that
590          might be convenient to do sometimes.  We support it by
591          interpreting the args like this:
592
593          ld.so PROGRAM ARGS...
594
595          The first argument is the name of a file containing an ELF
596          executable we will load and run with the following arguments.
597          To simplify life here, PROGRAM is searched for using the
598          normal rules for shared objects, rather than $PATH or anything
599          like that.  We just load it and use its entry point; we don't
600          pay attention to its PT_INTERP command (we are the interpreter
601          ourselves).  This is an easy way to test a new ld.so before
602          installing it.  */
603       rtld_is_main = true;
604
605       /* Note the place where the dynamic linker actually came from.  */
606       GL(dl_rtld_map).l_name = rtld_progname;
607
608       while (_dl_argc > 1)
609         if (! strcmp (INTUSE(_dl_argv)[1], "--list"))
610           {
611             mode = list;
612             GL(dl_lazy) = -1;   /* This means do no dependency analysis.  */
613
614             ++_dl_skip_args;
615             --_dl_argc;
616             ++INTUSE(_dl_argv);
617           }
618         else if (! strcmp (INTUSE(_dl_argv)[1], "--verify"))
619           {
620             mode = verify;
621
622             ++_dl_skip_args;
623             --_dl_argc;
624             ++INTUSE(_dl_argv);
625           }
626         else if (! strcmp (INTUSE(_dl_argv)[1], "--library-path")
627                  && _dl_argc > 2)
628           {
629             library_path = INTUSE(_dl_argv)[2];
630
631             _dl_skip_args += 2;
632             _dl_argc -= 2;
633             INTUSE(_dl_argv) += 2;
634           }
635         else if (! strcmp (INTUSE(_dl_argv)[1], "--inhibit-rpath")
636                  && _dl_argc > 2)
637           {
638             GL(dl_inhibit_rpath) = INTUSE(_dl_argv)[2];
639
640             _dl_skip_args += 2;
641             _dl_argc -= 2;
642             INTUSE(_dl_argv) += 2;
643           }
644         else
645           break;
646
647       /* If we have no further argument the program was called incorrectly.
648          Grant the user some education.  */
649       if (_dl_argc < 2)
650         _dl_fatal_printf ("\
651 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
652 You have invoked `ld.so', the helper program for shared library executables.\n\
653 This program usually lives in the file `/lib/ld.so', and special directives\n\
654 in executable files using ELF shared libraries tell the system's program\n\
655 loader to load the helper program from this file.  This helper program loads\n\
656 the shared libraries needed by the program executable, prepares the program\n\
657 to run, and runs it.  You may invoke this helper program directly from the\n\
658 command line to load and run an ELF executable file; this is like executing\n\
659 that file itself, but always uses this helper program from the file you\n\
660 specified, instead of the helper program file specified in the executable\n\
661 file you run.  This is mostly of use for maintainers to test new versions\n\
662 of this helper program; chances are you did not intend to run this program.\n\
663 \n\
664   --list                list all dependencies and how they are resolved\n\
665   --verify              verify that given object really is a dynamically linked\n\
666                         object we can handle\n\
667   --library-path PATH   use given PATH instead of content of the environment\n\
668                         variable LD_LIBRARY_PATH\n\
669   --inhibit-rpath LIST  ignore RUNPATH and RPATH information in object names\n\
670                         in LIST\n");
671
672       ++_dl_skip_args;
673       --_dl_argc;
674       ++INTUSE(_dl_argv);
675
676       /* Initialize the data structures for the search paths for shared
677          objects.  */
678       _dl_init_paths (library_path);
679
680       if (__builtin_expect (mode, normal) == verify)
681         {
682           const char *objname;
683           const char *err_str = NULL;
684           struct map_args args;
685
686           args.str = rtld_progname;
687           (void) INTUSE(_dl_catch_error) (&objname, &err_str, map_doit, &args);
688           if (__builtin_expect (err_str != NULL, 0))
689             /* We don't free the returned string, the programs stops
690                anyway.  */
691             _exit (EXIT_FAILURE);
692         }
693       else
694         {
695           HP_TIMING_NOW (start);
696           INTUSE(_dl_map_object) (NULL, rtld_progname, 0, lt_library, 0, 0);
697           HP_TIMING_NOW (stop);
698
699           HP_TIMING_DIFF (load_time, start, stop);
700         }
701
702       phdr = GL(dl_loaded)->l_phdr;
703       phnum = GL(dl_loaded)->l_phnum;
704       /* We overwrite here a pointer to a malloc()ed string.  But since
705          the malloc() implementation used at this point is the dummy
706          implementations which has no real free() function it does not
707          makes sense to free the old string first.  */
708       GL(dl_loaded)->l_name = (char *) "";
709       *user_entry = GL(dl_loaded)->l_entry;
710     }
711   else
712     {
713       /* Create a link_map for the executable itself.
714          This will be what dlopen on "" returns.  */
715       _dl_new_object ((char *) "", "", lt_executable, NULL);
716       if (GL(dl_loaded) == NULL)
717         _dl_fatal_printf ("cannot allocate memory for link map\n");
718       GL(dl_loaded)->l_phdr = phdr;
719       GL(dl_loaded)->l_phnum = phnum;
720       GL(dl_loaded)->l_entry = *user_entry;
721
722       /* At this point we are in a bit of trouble.  We would have to
723          fill in the values for l_dev and l_ino.  But in general we
724          do not know where the file is.  We also do not handle AT_EXECFD
725          even if it would be passed up.
726
727          We leave the values here defined to 0.  This is normally no
728          problem as the program code itself is normally no shared
729          object and therefore cannot be loaded dynamically.  Nothing
730          prevent the use of dynamic binaries and in these situations
731          we might get problems.  We might not be able to find out
732          whether the object is already loaded.  But since there is no
733          easy way out and because the dynamic binary must also not
734          have an SONAME we ignore this program for now.  If it becomes
735          a problem we can force people using SONAMEs.  */
736
737       /* We delay initializing the path structure until we got the dynamic
738          information for the program.  */
739     }
740
741   GL(dl_loaded)->l_map_end = 0;
742   /* Perhaps the executable has no PT_LOAD header entries at all.  */
743   GL(dl_loaded)->l_map_start = ~0;
744   /* We opened the file, account for it.  */
745   ++GL(dl_loaded)->l_opencount;
746
747   /* Scan the program header table for the dynamic section.  */
748   for (ph = phdr; ph < &phdr[phnum]; ++ph)
749     switch (ph->p_type)
750       {
751       case PT_PHDR:
752         /* Find out the load address.  */
753         GL(dl_loaded)->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
754         break;
755       case PT_DYNAMIC:
756         /* This tells us where to find the dynamic section,
757            which tells us everything we need to do.  */
758         GL(dl_loaded)->l_ld = (void *) GL(dl_loaded)->l_addr + ph->p_vaddr;
759         break;
760       case PT_INTERP:
761         /* This "interpreter segment" was used by the program loader to
762            find the program interpreter, which is this program itself, the
763            dynamic linker.  We note what name finds us, so that a future
764            dlopen call or DT_NEEDED entry, for something that wants to link
765            against the dynamic linker as a shared library, will know that
766            the shared object is already loaded.  */
767         _dl_rtld_libname.name = ((const char *) GL(dl_loaded)->l_addr
768                                  + ph->p_vaddr);
769         /* _dl_rtld_libname.next = NULL;        Already zero.  */
770         GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
771
772         /* Ordinarilly, we would get additional names for the loader from
773            our DT_SONAME.  This can't happen if we were actually linked as
774            a static executable (detect this case when we have no DYNAMIC).
775            If so, assume the filename component of the interpreter path to
776            be our SONAME, and add it to our name list.  */
777         if (GL(dl_rtld_map).l_ld == NULL)
778           {
779             const char *p = NULL;
780             const char *cp = _dl_rtld_libname.name;
781
782             /* Find the filename part of the path.  */
783             while (*cp != '\0')
784               if (*cp++ == '/')
785                 p = cp;
786
787             if (p != NULL)
788               {
789                 _dl_rtld_libname2.name = p;
790                 /* _dl_rtld_libname2.next = NULL;  Already zero.  */
791                 _dl_rtld_libname.next = &_dl_rtld_libname2;
792               }
793           }
794
795         has_interp = true;
796         break;
797       case PT_LOAD:
798         {
799           ElfW(Addr) mapstart;
800           ElfW(Addr) allocend;
801
802           /* Remember where the main program starts in memory.  */
803           mapstart = (GL(dl_loaded)->l_addr
804                       + (ph->p_vaddr & ~(ph->p_align - 1)));
805           if (GL(dl_loaded)->l_map_start > mapstart)
806             GL(dl_loaded)->l_map_start = mapstart;
807
808           /* Also where it ends.  */
809           allocend = GL(dl_loaded)->l_addr + ph->p_vaddr + ph->p_memsz;
810           if (GL(dl_loaded)->l_map_end < allocend)
811             GL(dl_loaded)->l_map_end = allocend;
812         }
813         break;
814 #ifdef USE_TLS
815       case PT_TLS:
816         if (ph->p_memsz > 0)
817           {
818             /* Note that in the case the dynamic linker we duplicate work
819                here since we read the PT_TLS entry already in
820                _dl_start_final.  But the result is repeatable so do not
821                check for this special but unimportant case.  */
822             GL(dl_loaded)->l_tls_blocksize = ph->p_memsz;
823             GL(dl_loaded)->l_tls_align = ph->p_align;
824             GL(dl_loaded)->l_tls_initimage_size = ph->p_filesz;
825             GL(dl_loaded)->l_tls_initimage = (void *) ph->p_vaddr;
826
827             /* This image gets the ID one.  */
828             GL(dl_tls_max_dtv_idx) = GL(dl_loaded)->l_tls_modid = 1;
829           }
830         break;
831 #endif
832       }
833   if (! GL(dl_loaded)->l_map_end)
834     GL(dl_loaded)->l_map_end = ~0;
835   if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
836     {
837       /* We were invoked directly, so the program might not have a
838          PT_INTERP.  */
839       _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
840       /* _dl_rtld_libname.next = NULL;  Already zero.  */
841       GL(dl_rtld_map).l_libname =  &_dl_rtld_libname;
842     }
843   else
844     assert (GL(dl_rtld_map).l_libname); /* How else did we get here?  */
845
846   if (! rtld_is_main)
847     {
848       /* Extract the contents of the dynamic section for easy access.  */
849       elf_get_dynamic_info (GL(dl_loaded));
850       if (GL(dl_loaded)->l_info[DT_HASH])
851         /* Set up our cache of pointers into the hash table.  */
852         _dl_setup_hash (GL(dl_loaded));
853     }
854
855   if (__builtin_expect (mode, normal) == verify)
856     {
857       /* We were called just to verify that this is a dynamic
858          executable using us as the program interpreter.  Exit with an
859          error if we were not able to load the binary or no interpreter
860          is specified (i.e., this is no dynamically linked binary.  */
861       if (GL(dl_loaded)->l_ld == NULL)
862         _exit (1);
863
864       /* We allow here some platform specific code.  */
865 #ifdef DISTINGUISH_LIB_VERSIONS
866       DISTINGUISH_LIB_VERSIONS;
867 #endif
868       _exit (has_interp ? 0 : 2);
869     }
870
871   if (! rtld_is_main)
872     /* Initialize the data structures for the search paths for shared
873        objects.  */
874     _dl_init_paths (library_path);
875
876   /* Put the link_map for ourselves on the chain so it can be found by
877      name.  Note that at this point the global chain of link maps contains
878      exactly one element, which is pointed to by dl_loaded.  */
879   if (! GL(dl_rtld_map).l_name)
880     /* If not invoked directly, the dynamic linker shared object file was
881        found by the PT_INTERP name.  */
882     GL(dl_rtld_map).l_name = (char *) GL(dl_rtld_map).l_libname->name;
883   GL(dl_rtld_map).l_type = lt_library;
884   GL(dl_loaded)->l_next = &GL(dl_rtld_map);
885   GL(dl_rtld_map).l_prev = GL(dl_loaded);
886   ++GL(dl_nloaded);
887
888   /* We have two ways to specify objects to preload: via environment
889      variable and via the file /etc/ld.so.preload.  The latter can also
890      be used when security is enabled.  */
891   preloads = NULL;
892   npreloads = 0;
893
894   if (__builtin_expect (preloadlist != NULL, 0))
895     {
896       /* The LD_PRELOAD environment variable gives list of libraries
897          separated by white space or colons that are loaded before the
898          executable's dependencies and prepended to the global scope
899          list.  If the binary is running setuid all elements
900          containing a '/' are ignored since it is insecure.  */
901       char *list = strdupa (preloadlist);
902       char *p;
903
904       HP_TIMING_NOW (start);
905
906       /* Prevent optimizing strsep.  Speed is not important here.  */
907       while ((p = (strsep) (&list, " :")) != NULL)
908         if (p[0] != '\0'
909             && (__builtin_expect (! INTUSE(__libc_enable_secure), 1)
910                 || strchr (p, '/') == NULL))
911           {
912             struct link_map *new_map = INTUSE(_dl_map_object) (GL(dl_loaded),
913                                                                p, 1,
914                                                                lt_library,
915                                                                0, 0);
916             if (++new_map->l_opencount == 1)
917               /* It is no duplicate.  */
918               ++npreloads;
919           }
920
921       HP_TIMING_NOW (stop);
922       HP_TIMING_DIFF (diff, start, stop);
923       HP_TIMING_ACCUM_NT (load_time, diff);
924     }
925
926   /* Read the contents of the file.  */
927   file = _dl_sysdep_read_whole_file ("/etc/ld.so.preload", &file_size,
928                                      PROT_READ | PROT_WRITE);
929   if (__builtin_expect (file != MAP_FAILED, 0))
930     {
931       /* Parse the file.  It contains names of libraries to be loaded,
932          separated by white spaces or `:'.  It may also contain
933          comments introduced by `#'.  */
934       char *problem;
935       char *runp;
936       size_t rest;
937
938       /* Eliminate comments.  */
939       runp = file;
940       rest = file_size;
941       while (rest > 0)
942         {
943           char *comment = memchr (runp, '#', rest);
944           if (comment == NULL)
945             break;
946
947           rest -= comment - runp;
948           do
949             *comment = ' ';
950           while (--rest > 0 && *++comment != '\n');
951         }
952
953       /* We have one problematic case: if we have a name at the end of
954          the file without a trailing terminating characters, we cannot
955          place the \0.  Handle the case separately.  */
956       if (file[file_size - 1] != ' ' && file[file_size - 1] != '\t'
957           && file[file_size - 1] != '\n' && file[file_size - 1] != ':')
958         {
959           problem = &file[file_size];
960           while (problem > file && problem[-1] != ' ' && problem[-1] != '\t'
961                  && problem[-1] != '\n' && problem[-1] != ':')
962             --problem;
963
964           if (problem > file)
965             problem[-1] = '\0';
966         }
967       else
968         {
969           problem = NULL;
970           file[file_size - 1] = '\0';
971         }
972
973       HP_TIMING_NOW (start);
974
975       if (file != problem)
976         {
977           char *p;
978           runp = file;
979           while ((p = strsep (&runp, ": \t\n")) != NULL)
980             if (p[0] != '\0')
981               {
982                 struct link_map *new_map = INTUSE(_dl_map_object) (GL(dl_loaded),
983                                                                    p, 1,
984                                                                    lt_library,
985                                                                    0, 0);
986                 if (++new_map->l_opencount == 1)
987                   /* It is no duplicate.  */
988                   ++npreloads;
989               }
990         }
991
992       if (problem != NULL)
993         {
994           char *p = strndupa (problem, file_size - (problem - file));
995           struct link_map *new_map = INTUSE(_dl_map_object) (GL(dl_loaded), p,
996                                                              1, lt_library,
997                                                              0, 0);
998           if (++new_map->l_opencount == 1)
999             /* It is no duplicate.  */
1000             ++npreloads;
1001         }
1002
1003       HP_TIMING_NOW (stop);
1004       HP_TIMING_DIFF (diff, start, stop);
1005       HP_TIMING_ACCUM_NT (load_time, diff);
1006
1007       /* We don't need the file anymore.  */
1008       __munmap (file, file_size);
1009     }
1010
1011   if (__builtin_expect (npreloads, 0) != 0)
1012     {
1013       /* Set up PRELOADS with a vector of the preloaded libraries.  */
1014       struct link_map *l;
1015       preloads = __alloca (npreloads * sizeof preloads[0]);
1016       l = GL(dl_rtld_map).l_next; /* End of the chain before preloads.  */
1017       i = 0;
1018       do
1019         {
1020           preloads[i++] = l;
1021           l = l->l_next;
1022         } while (l);
1023       assert (i == npreloads);
1024     }
1025
1026   /* Load all the libraries specified by DT_NEEDED entries.  If LD_PRELOAD
1027      specified some libraries to load, these are inserted before the actual
1028      dependencies in the executable's searchlist for symbol resolution.  */
1029   HP_TIMING_NOW (start);
1030   INTUSE(_dl_map_object_deps) (GL(dl_loaded), preloads, npreloads,
1031                                mode == trace, 0);
1032   HP_TIMING_NOW (stop);
1033   HP_TIMING_DIFF (diff, start, stop);
1034   HP_TIMING_ACCUM_NT (load_time, diff);
1035
1036   /* Mark all objects as being in the global scope and set the open
1037      counter.  */
1038   for (i = GL(dl_loaded)->l_searchlist.r_nlist; i > 0; )
1039     {
1040       --i;
1041       GL(dl_loaded)->l_searchlist.r_list[i]->l_global = 1;
1042       ++GL(dl_loaded)->l_searchlist.r_list[i]->l_opencount;
1043     }
1044
1045 #ifndef MAP_ANON
1046   /* We are done mapping things, so close the zero-fill descriptor.  */
1047   __close (_dl_zerofd);
1048   _dl_zerofd = -1;
1049 #endif
1050
1051   /* Remove _dl_rtld_map from the chain.  */
1052   GL(dl_rtld_map).l_prev->l_next = GL(dl_rtld_map).l_next;
1053   if (GL(dl_rtld_map).l_next)
1054     GL(dl_rtld_map).l_next->l_prev = GL(dl_rtld_map).l_prev;
1055
1056   if (__builtin_expect (GL(dl_rtld_map).l_opencount > 1, 1))
1057     {
1058       /* Some DT_NEEDED entry referred to the interpreter object itself, so
1059          put it back in the list of visible objects.  We insert it into the
1060          chain in symbol search order because gdb uses the chain's order as
1061          its symbol search order.  */
1062       i = 1;
1063       while (GL(dl_loaded)->l_searchlist.r_list[i] != &GL(dl_rtld_map))
1064         ++i;
1065       GL(dl_rtld_map).l_prev = GL(dl_loaded)->l_searchlist.r_list[i - 1];
1066       if (__builtin_expect (mode, normal) == normal)
1067         GL(dl_rtld_map).l_next = (i + 1 < GL(dl_loaded)->l_searchlist.r_nlist
1068                                   ? GL(dl_loaded)->l_searchlist.r_list[i + 1]
1069                                   : NULL);
1070       else
1071         /* In trace mode there might be an invisible object (which we
1072            could not find) after the previous one in the search list.
1073            In this case it doesn't matter much where we put the
1074            interpreter object, so we just initialize the list pointer so
1075            that the assertion below holds.  */
1076         GL(dl_rtld_map).l_next = GL(dl_rtld_map).l_prev->l_next;
1077
1078       assert (GL(dl_rtld_map).l_prev->l_next == GL(dl_rtld_map).l_next);
1079       GL(dl_rtld_map).l_prev->l_next = &GL(dl_rtld_map);
1080       if (GL(dl_rtld_map).l_next != NULL)
1081         {
1082           assert (GL(dl_rtld_map).l_next->l_prev == GL(dl_rtld_map).l_prev);
1083           GL(dl_rtld_map).l_next->l_prev = &GL(dl_rtld_map);
1084         }
1085     }
1086
1087   /* Now let us see whether all libraries are available in the
1088      versions we need.  */
1089   {
1090     struct version_check_args args;
1091     args.doexit = mode == normal;
1092     args.dotrace = mode == trace;
1093     _dl_receive_error (print_missing_version, version_check_doit, &args);
1094   }
1095
1096 #ifdef USE_TLS
1097   /* Now it is time to determine the layout of the static TLS block
1098      and allocate it for the initial thread.  Note that we always
1099      allocate the static block, we never defer it even if no
1100      DF_STATIC_TLS bit is set.  The reason is that we know glibc will
1101      use the static model.  First add the dynamic linker to the list
1102      if it also uses TLS.  */
1103   if (GL(dl_rtld_map).l_tls_blocksize != 0)
1104     /* Assign a module ID.  */
1105     GL(dl_rtld_map).l_tls_modid = _dl_next_tls_modid ();
1106
1107 # ifndef SHARED
1108   /* If dynamic loading of modules with TLS is impossible we do not
1109      have to initialize any of the TLS functionality unless any of the
1110      initial modules uses TLS.  */
1111   if (GL(dl_tls_max_dtv_idx) > 0)
1112 # endif
1113     {
1114       struct link_map *l;
1115       size_t nelem;
1116       struct dtv_slotinfo *slotinfo;
1117
1118       /* Number of elements in the static TLS block.  */
1119       GL(dl_tls_static_nelem) = GL(dl_tls_max_dtv_idx);
1120
1121       /* Allocate the array which contains the information about the
1122          dtv slots.  We allocate a few entries more than needed to
1123          avoid the need for reallocation.  */
1124       nelem = GL(dl_tls_max_dtv_idx) + 1 + TLS_SLOTINFO_SURPLUS;
1125
1126       /* Allocate.  */
1127       GL(dl_tls_dtv_slotinfo_list) = (struct dtv_slotinfo_list *)
1128         malloc (sizeof (struct dtv_slotinfo_list)
1129                 + nelem * sizeof (struct dtv_slotinfo));
1130       /* No need to check the return value.  If memory allocation failed
1131          the program would have been terminated.  */
1132
1133       slotinfo = memset (GL(dl_tls_dtv_slotinfo_list)->slotinfo, '\0',
1134                          nelem * sizeof (struct dtv_slotinfo));
1135       GL(dl_tls_dtv_slotinfo_list)->len = nelem;
1136       GL(dl_tls_dtv_slotinfo_list)->next = NULL;
1137
1138       /* Fill in the information from the loaded modules.  */
1139       for (l = GL(dl_loaded), i = 0; l != NULL; l = l->l_next)
1140         if (l->l_tls_blocksize != 0)
1141           /* This is a module with TLS data.  Store the map reference.
1142              The generation counter is zero.  */
1143           slotinfo[++i].map = l;
1144       assert (i == GL(dl_tls_max_dtv_idx));
1145
1146       /* Compute the TLS offsets for the various blocks.  We call this
1147          function even if none of the modules available at startup time
1148          uses TLS to initialize some variables.  */
1149       _dl_determine_tlsoffset ();
1150
1151       /* Construct the static TLS block and the dtv for the initial
1152          thread.  For some platforms this will include allocating memory
1153          for the thread descriptor.  The memory for the TLS block will
1154          never be freed.  It should be allocated accordingly.  The dtv
1155          array can be changed if dynamic loading requires it.  */
1156       tcbp = _dl_allocate_tls_storage ();
1157       if (tcbp == NULL)
1158         _dl_fatal_printf ("\
1159 cannot allocate TLS data structures for initial thread");
1160
1161       /* Store for detection of the special case by __tls_get_addr
1162          so it knows not to pass this dtv to the normal realloc.  */
1163       GL(dl_initial_dtv) = GET_DTV (tcbp);
1164     }
1165 #endif
1166
1167   if (__builtin_expect (mode, normal) != normal)
1168     {
1169       /* We were run just to list the shared libraries.  It is
1170          important that we do this before real relocation, because the
1171          functions we call below for output may no longer work properly
1172          after relocation.  */
1173       if (! GL(dl_loaded)->l_info[DT_NEEDED])
1174         _dl_printf ("\tstatically linked\n");
1175       else
1176         {
1177           struct link_map *l;
1178
1179           if (GL(dl_debug_mask) & DL_DEBUG_PRELINK)
1180             {
1181               struct r_scope_elem *scope = &GL(dl_loaded)->l_searchlist;
1182
1183               for (i = 0; i < scope->r_nlist; i++)
1184                 {
1185                   l = scope->r_list [i];
1186                   if (l->l_faked)
1187                     {
1188                       _dl_printf ("\t%s => not found\n", l->l_libname->name);
1189                       continue;
1190                     }
1191                   if (_dl_name_match_p (GL(dl_trace_prelink), l))
1192                     GL(dl_trace_prelink_map) = l;
1193                   _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1194                               l->l_libname->name[0] ? l->l_libname->name
1195                               : rtld_progname ?: "<main program>",
1196                               l->l_name[0] ? l->l_name
1197                               : rtld_progname ?: "<main program>",
1198                               (int) sizeof l->l_map_start * 2,
1199                               l->l_map_start,
1200                               (int) sizeof l->l_addr * 2,
1201                               l->l_addr);
1202 #ifdef USE_TLS
1203                   if (l->l_tls_modid)
1204                     _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l->l_tls_modid,
1205                                 (int) sizeof l->l_tls_offset * 2,
1206                                 l->l_tls_offset);
1207                   else
1208 #endif
1209                     _dl_printf ("\n");
1210                 }
1211             }
1212           else
1213             {
1214               for (l = GL(dl_loaded)->l_next; l; l = l->l_next)
1215                 if (l->l_faked)
1216                   /* The library was not found.  */
1217                   _dl_printf ("\t%s => not found\n", l->l_libname->name);
1218                 else
1219                   _dl_printf ("\t%s => %s (0x%0*Zx)\n", l->l_libname->name,
1220                               l->l_name, (int) sizeof l->l_map_start * 2,
1221                               l->l_map_start);
1222             }
1223         }
1224
1225       if (__builtin_expect (mode, trace) != trace)
1226         for (i = 1; i < (unsigned int) _dl_argc; ++i)
1227           {
1228             const ElfW(Sym) *ref = NULL;
1229             ElfW(Addr) loadbase;
1230             lookup_t result;
1231
1232             result = INTUSE(_dl_lookup_symbol) (INTUSE(_dl_argv)[i],
1233                                                 GL(dl_loaded),
1234                                                 &ref, GL(dl_loaded)->l_scope,
1235                                                 ELF_RTYPE_CLASS_PLT, 1);
1236
1237             loadbase = LOOKUP_VALUE_ADDRESS (result);
1238
1239             _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1240                         INTUSE(_dl_argv)[i],
1241                         (int) sizeof ref->st_value * 2, ref->st_value,
1242                         (int) sizeof loadbase * 2, loadbase);
1243           }
1244       else
1245         {
1246           /* If LD_WARN is set warn about undefined symbols.  */
1247           if (GL(dl_lazy) >= 0 && GL(dl_verbose))
1248             {
1249               /* We have to do symbol dependency testing.  */
1250               struct relocate_args args;
1251               struct link_map *l;
1252
1253               args.lazy = GL(dl_lazy);
1254
1255               l = GL(dl_loaded);
1256               while (l->l_next)
1257                 l = l->l_next;
1258               do
1259                 {
1260                   if (l != &GL(dl_rtld_map) && ! l->l_faked)
1261                     {
1262                       args.l = l;
1263                       _dl_receive_error (print_unresolved, relocate_doit,
1264                                          &args);
1265                     }
1266                   l = l->l_prev;
1267                 } while (l);
1268
1269               if ((GL(dl_debug_mask) & DL_DEBUG_PRELINK)
1270                   && GL(dl_rtld_map).l_opencount > 1)
1271                 INTUSE(_dl_relocate_object) (&GL(dl_rtld_map),
1272                                              GL(dl_loaded)->l_scope, 0, 0);
1273             }
1274
1275 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
1276           if (version_info)
1277             {
1278               /* Print more information.  This means here, print information
1279                  about the versions needed.  */
1280               int first = 1;
1281               struct link_map *map = GL(dl_loaded);
1282
1283               for (map = GL(dl_loaded); map != NULL; map = map->l_next)
1284                 {
1285                   const char *strtab;
1286                   ElfW(Dyn) *dyn = map->l_info[VERNEEDTAG];
1287                   ElfW(Verneed) *ent;
1288
1289                   if (dyn == NULL)
1290                     continue;
1291
1292                   strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
1293                   ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
1294
1295                   if (first)
1296                     {
1297                       _dl_printf ("\n\tVersion information:\n");
1298                       first = 0;
1299                     }
1300
1301                   _dl_printf ("\t%s:\n",
1302                               map->l_name[0] ? map->l_name : rtld_progname);
1303
1304                   while (1)
1305                     {
1306                       ElfW(Vernaux) *aux;
1307                       struct link_map *needed;
1308
1309                       needed = find_needed (strtab + ent->vn_file);
1310                       aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
1311
1312                       while (1)
1313                         {
1314                           const char *fname = NULL;
1315
1316                           if (needed != NULL
1317                               && match_version (strtab + aux->vna_name,
1318                                                 needed))
1319                             fname = needed->l_name;
1320
1321                           _dl_printf ("\t\t%s (%s) %s=> %s\n",
1322                                       strtab + ent->vn_file,
1323                                       strtab + aux->vna_name,
1324                                       aux->vna_flags & VER_FLG_WEAK
1325                                       ? "[WEAK] " : "",
1326                                       fname ?: "not found");
1327
1328                           if (aux->vna_next == 0)
1329                             /* No more symbols.  */
1330                             break;
1331
1332                           /* Next symbol.  */
1333                           aux = (ElfW(Vernaux) *) ((char *) aux
1334                                                    + aux->vna_next);
1335                         }
1336
1337                       if (ent->vn_next == 0)
1338                         /* No more dependencies.  */
1339                         break;
1340
1341                       /* Next dependency.  */
1342                       ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
1343                     }
1344                 }
1345             }
1346         }
1347
1348       _exit (0);
1349     }
1350
1351   if (GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_LIBLIST)]
1352       && ! __builtin_expect (GL(dl_profile) != NULL, 0))
1353     {
1354       ElfW(Lib) *liblist, *liblistend;
1355       struct link_map **r_list, **r_listend, *l;
1356       const char *strtab = (const void *) D_PTR (GL(dl_loaded),
1357                                                  l_info[DT_STRTAB]);
1358
1359       assert (GL(dl_loaded)->l_info [VALIDX (DT_GNU_LIBLISTSZ)] != NULL);
1360       liblist = (ElfW(Lib) *)
1361                 GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_LIBLIST)]->d_un.d_ptr;
1362       liblistend = (ElfW(Lib) *)
1363                    ((char *) liblist
1364                     + GL(dl_loaded)->l_info [VALIDX (DT_GNU_LIBLISTSZ)]->d_un.d_val);
1365       r_list = GL(dl_loaded)->l_searchlist.r_list;
1366       r_listend = r_list + GL(dl_loaded)->l_searchlist.r_nlist;
1367
1368       for (; r_list < r_listend && liblist < liblistend; r_list++)
1369         {
1370           l = *r_list;
1371
1372           if (l == GL(dl_loaded))
1373             continue;
1374
1375           /* If the library is not mapped where it should, fail.  */
1376           if (l->l_addr)
1377             break;
1378
1379           /* Next, check if checksum matches.  */
1380           if (l->l_info [VALIDX(DT_CHECKSUM)] == NULL
1381               || l->l_info [VALIDX(DT_CHECKSUM)]->d_un.d_val
1382                  != liblist->l_checksum)
1383             break;
1384
1385           if (l->l_info [VALIDX(DT_GNU_PRELINKED)] == NULL
1386               || l->l_info [VALIDX(DT_GNU_PRELINKED)]->d_un.d_val
1387                  != liblist->l_time_stamp)
1388             break;
1389
1390           if (! _dl_name_match_p (strtab + liblist->l_name, l))
1391             break;
1392
1393           ++liblist;
1394         }
1395
1396
1397       if (r_list == r_listend && liblist == liblistend)
1398         prelinked = true;
1399
1400       if (__builtin_expect (GL(dl_debug_mask) & DL_DEBUG_LIBS, 0))
1401         _dl_printf ("\nprelink checking: %s\n", prelinked ? "ok" : "failed");
1402     }
1403
1404   if (prelinked)
1405     {
1406       if (GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_CONFLICT)] != NULL)
1407         {
1408           ElfW(Rela) *conflict, *conflictend;
1409 #ifndef HP_TIMING_NONAVAIL
1410           hp_timing_t start;
1411           hp_timing_t stop;
1412 #endif
1413
1414           HP_TIMING_NOW (start);
1415           assert (GL(dl_loaded)->l_info [VALIDX (DT_GNU_CONFLICTSZ)] != NULL);
1416           conflict = (ElfW(Rela) *)
1417                      GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_CONFLICT)]->d_un.d_ptr;
1418           conflictend = (ElfW(Rela) *)
1419                         ((char *) conflict
1420                          + GL(dl_loaded)->l_info [VALIDX (DT_GNU_CONFLICTSZ)]->d_un.d_val);
1421           _dl_resolve_conflicts (GL(dl_loaded), conflict, conflictend);
1422           HP_TIMING_NOW (stop);
1423           HP_TIMING_DIFF (relocate_time, start, stop);
1424         }
1425
1426       _dl_sysdep_start_cleanup ();
1427     }
1428   else
1429     {
1430       /* Now we have all the objects loaded.  Relocate them all except for
1431          the dynamic linker itself.  We do this in reverse order so that copy
1432          relocs of earlier objects overwrite the data written by later
1433          objects.  We do not re-relocate the dynamic linker itself in this
1434          loop because that could result in the GOT entries for functions we
1435          call being changed, and that would break us.  It is safe to relocate
1436          the dynamic linker out of order because it has no copy relocs (we
1437          know that because it is self-contained).  */
1438
1439       struct link_map *l;
1440       int consider_profiling = GL(dl_profile) != NULL;
1441 #ifndef HP_TIMING_NONAVAIL
1442       hp_timing_t start;
1443       hp_timing_t stop;
1444       hp_timing_t add;
1445 #endif
1446
1447       /* If we are profiling we also must do lazy reloaction.  */
1448       GL(dl_lazy) |= consider_profiling;
1449
1450       l = GL(dl_loaded);
1451       while (l->l_next)
1452         l = l->l_next;
1453
1454       HP_TIMING_NOW (start);
1455       do
1456         {
1457           /* While we are at it, help the memory handling a bit.  We have to
1458              mark some data structures as allocated with the fake malloc()
1459              implementation in ld.so.  */
1460           struct libname_list *lnp = l->l_libname->next;
1461
1462           while (__builtin_expect (lnp != NULL, 0))
1463             {
1464               lnp->dont_free = 1;
1465               lnp = lnp->next;
1466             }
1467
1468           if (l != &GL(dl_rtld_map))
1469             INTUSE(_dl_relocate_object) (l, l->l_scope, GL(dl_lazy),
1470                                          consider_profiling);
1471
1472           l = l->l_prev;
1473         }
1474       while (l);
1475       HP_TIMING_NOW (stop);
1476
1477       HP_TIMING_DIFF (relocate_time, start, stop);
1478
1479       /* Do any necessary cleanups for the startup OS interface code.
1480          We do these now so that no calls are made after rtld re-relocation
1481          which might be resolved to different functions than we expect.
1482          We cannot do this before relocating the other objects because
1483          _dl_relocate_object might need to call `mprotect' for DT_TEXTREL.  */
1484       _dl_sysdep_start_cleanup ();
1485
1486       /* Now enable profiling if needed.  Like the previous call,
1487          this has to go here because the calls it makes should use the
1488          rtld versions of the functions (particularly calloc()), but it
1489          needs to have _dl_profile_map set up by the relocator.  */
1490       if (__builtin_expect (GL(dl_profile_map) != NULL, 0))
1491         /* We must prepare the profiling.  */
1492         INTUSE(_dl_start_profile) (GL(dl_profile_map), GL(dl_profile_output));
1493
1494       if (GL(dl_rtld_map).l_opencount > 1)
1495         {
1496           /* There was an explicit ref to the dynamic linker as a shared lib.
1497              Re-relocate ourselves with user-controlled symbol definitions.  */
1498           HP_TIMING_NOW (start);
1499           INTUSE(_dl_relocate_object) (&GL(dl_rtld_map), GL(dl_loaded)->l_scope,
1500                                        0, 0);
1501           HP_TIMING_NOW (stop);
1502           HP_TIMING_DIFF (add, start, stop);
1503           HP_TIMING_ACCUM_NT (relocate_time, add);
1504         }
1505     }
1506
1507   /* Now set up the variable which helps the assembler startup code.  */
1508   GL(dl_main_searchlist) = &GL(dl_loaded)->l_searchlist;
1509   GL(dl_global_scope)[0] = &GL(dl_loaded)->l_searchlist;
1510
1511   /* Save the information about the original global scope list since
1512      we need it in the memory handling later.  */
1513   GL(dl_initial_searchlist) = *GL(dl_main_searchlist);
1514
1515 #ifdef USE_TLS
1516 # ifndef SHARED
1517   if (GL(dl_tls_max_dtv_idx) > 0)
1518 # endif
1519     {
1520       /* Now that we have completed relocation, the initializer data
1521          for the TLS blocks has its final values and we can copy them
1522          into the main thread's TLS area, which we allocated above.  */
1523       _dl_allocate_tls_init (tcbp);
1524
1525       /* And finally install it for the main thread.  */
1526 # ifndef HAVE___THREAD
1527       TLS_INIT_TP (tcbp, GL(dl_rtld_map).l_tls_tp_initialized);
1528 # else
1529       /* If the compiler supports the __thread keyword we know that
1530          at least ld.so itself uses TLS and therefore the thread
1531          pointer was initialized earlier.  */
1532       assert (GL(dl_rtld_map).l_tls_tp_initialized != 0);
1533       TLS_INIT_TP (tcbp, 1);
1534 # endif
1535     }
1536 #endif
1537
1538   {
1539     /* Initialize _r_debug.  */
1540     struct r_debug *r = _dl_debug_initialize (GL(dl_rtld_map).l_addr);
1541     struct link_map *l;
1542
1543     l = GL(dl_loaded);
1544
1545 #ifdef ELF_MACHINE_DEBUG_SETUP
1546
1547     /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way.  */
1548
1549     ELF_MACHINE_DEBUG_SETUP (l, r);
1550     ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map), r);
1551
1552 #else
1553
1554     if (l->l_info[DT_DEBUG] != NULL)
1555       /* There is a DT_DEBUG entry in the dynamic section.  Fill it in
1556          with the run-time address of the r_debug structure  */
1557       l->l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1558
1559     /* Fill in the pointer in the dynamic linker's own dynamic section, in
1560        case you run gdb on the dynamic linker directly.  */
1561     if (GL(dl_rtld_map).l_info[DT_DEBUG] != NULL)
1562       GL(dl_rtld_map).l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1563
1564 #endif
1565
1566     /* Notify the debugger that all objects are now mapped in.  */
1567     r->r_state = RT_ADD;
1568     INTUSE(_dl_debug_state) ();
1569   }
1570
1571 #ifndef MAP_COPY
1572   /* We must munmap() the cache file.  */
1573   INTUSE(_dl_unload_cache) ();
1574 #endif
1575
1576   /* Once we return, _dl_sysdep_start will invoke
1577      the DT_INIT functions and then *USER_ENTRY.  */
1578 }
1579 \f
1580 /* This is a little helper function for resolving symbols while
1581    tracing the binary.  */
1582 static void
1583 print_unresolved (int errcode __attribute__ ((unused)), const char *objname,
1584                   const char *errstring)
1585 {
1586   if (objname[0] == '\0')
1587     objname = rtld_progname ?: "<main program>";
1588   _dl_error_printf ("%s (%s)\n", errstring, objname);
1589 }
1590 \f
1591 /* This is a little helper function for resolving symbols while
1592    tracing the binary.  */
1593 static void
1594 print_missing_version (int errcode __attribute__ ((unused)),
1595                        const char *objname, const char *errstring)
1596 {
1597   _dl_error_printf ("%s: %s: %s\n", rtld_progname ?: "<program name unknown>",
1598                     objname, errstring);
1599 }
1600 \f
1601 /* Nonzero if any of the debugging options is enabled.  */
1602 static int any_debug;
1603
1604 /* Process the string given as the parameter which explains which debugging
1605    options are enabled.  */
1606 static void
1607 process_dl_debug (const char *dl_debug)
1608 {
1609   /* When adding new entries make sure that the maximal length of a name
1610      is correctly handled in the LD_DEBUG_HELP code below.  */
1611   static const struct
1612   {
1613     unsigned char len;
1614     const char name[10];
1615     const char helptext[41];
1616     unsigned short int mask;
1617   } debopts[] =
1618     {
1619 #define LEN_AND_STR(str) sizeof (str) - 1, str
1620       { LEN_AND_STR ("libs"), "display library search paths",
1621         DL_DEBUG_LIBS | DL_DEBUG_IMPCALLS },
1622       { LEN_AND_STR ("reloc"), "display relocation processing",
1623         DL_DEBUG_RELOC | DL_DEBUG_IMPCALLS },
1624       { LEN_AND_STR ("files"), "display progress for input file",
1625         DL_DEBUG_FILES | DL_DEBUG_IMPCALLS },
1626       { LEN_AND_STR ("symbols"), "display symbol table processing",
1627         DL_DEBUG_SYMBOLS | DL_DEBUG_IMPCALLS },
1628       { LEN_AND_STR ("bindings"), "display information about symbol binding",
1629         DL_DEBUG_BINDINGS | DL_DEBUG_IMPCALLS },
1630       { LEN_AND_STR ("versions"), "display version dependencies",
1631         DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
1632       { LEN_AND_STR ("all"), "all previous options combined",
1633         DL_DEBUG_LIBS | DL_DEBUG_RELOC | DL_DEBUG_FILES | DL_DEBUG_SYMBOLS
1634         | DL_DEBUG_BINDINGS | DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
1635       { LEN_AND_STR ("statistics"), "display relocation statistics",
1636         DL_DEBUG_STATISTICS },
1637       { LEN_AND_STR ("help"), "display this help message and exit",
1638         DL_DEBUG_HELP },
1639     };
1640 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
1641
1642   /* Skip separating white spaces and commas.  */
1643   while (*dl_debug != '\0')
1644     {
1645       if (*dl_debug != ' ' && *dl_debug != ',' && *dl_debug != ':')
1646         {
1647           size_t cnt;
1648           size_t len = 1;
1649
1650           while (dl_debug[len] != '\0' && dl_debug[len] != ' '
1651                  && dl_debug[len] != ',' && dl_debug[len] != ':')
1652             ++len;
1653
1654           for (cnt = 0; cnt < ndebopts; ++cnt)
1655             if (debopts[cnt].len == len
1656                 && memcmp (dl_debug, debopts[cnt].name, len) == 0)
1657               {
1658                 GL(dl_debug_mask) |= debopts[cnt].mask;
1659                 any_debug = 1;
1660                 break;
1661               }
1662
1663           if (cnt == ndebopts)
1664             {
1665               /* Display a warning and skip everything until next
1666                  separator.  */
1667               char *copy = strndupa (dl_debug, len);
1668               _dl_error_printf ("\
1669 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy);
1670             }
1671
1672           dl_debug += len;
1673           continue;
1674         }
1675
1676       ++dl_debug;
1677     }
1678
1679   if (GL(dl_debug_mask) & DL_DEBUG_HELP)
1680     {
1681       size_t cnt;
1682
1683       _dl_printf ("\
1684 Valid options for the LD_DEBUG environment variable are:\n\n");
1685
1686       for (cnt = 0; cnt < ndebopts; ++cnt)
1687         _dl_printf ("  %.*s%s%s\n", debopts[cnt].len, debopts[cnt].name,
1688                     "         " + debopts[cnt].len - 3,
1689                     debopts[cnt].helptext);
1690
1691       _dl_printf ("\n\
1692 To direct the debugging output into a file instead of standard output\n\
1693 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
1694       _exit (0);
1695     }
1696 }
1697 \f
1698 /* Process all environments variables the dynamic linker must recognize.
1699    Since all of them start with `LD_' we are a bit smarter while finding
1700    all the entries.  */
1701 extern char **_environ attribute_hidden;
1702
1703
1704 static void
1705 process_envvars (enum mode *modep)
1706 {
1707   char **runp = _environ;
1708   char *envline;
1709   enum mode mode = normal;
1710   char *debug_output = NULL;
1711
1712   /* This is the default place for profiling data file.  */
1713   GL(dl_profile_output)
1714     = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure) ? 9 : 0];
1715
1716   while ((envline = _dl_next_ld_env_entry (&runp)) != NULL)
1717     {
1718       size_t len = 0;
1719
1720       while (envline[len] != '\0' && envline[len] != '=')
1721         ++len;
1722
1723       if (envline[len] != '=')
1724         /* This is a "LD_" variable at the end of the string without
1725            a '=' character.  Ignore it since otherwise we will access
1726            invalid memory below.  */
1727         continue;
1728
1729       switch (len)
1730         {
1731         case 4:
1732           /* Warning level, verbose or not.  */
1733           if (memcmp (envline, "WARN", 4) == 0)
1734             GL(dl_verbose) = envline[5] != '\0';
1735           break;
1736
1737         case 5:
1738           /* Debugging of the dynamic linker?  */
1739           if (memcmp (envline, "DEBUG", 5) == 0)
1740             process_dl_debug (&envline[6]);
1741           break;
1742
1743         case 7:
1744           /* Print information about versions.  */
1745           if (memcmp (envline, "VERBOSE", 7) == 0)
1746             {
1747               version_info = envline[8] != '\0';
1748               break;
1749             }
1750
1751           /* List of objects to be preloaded.  */
1752           if (memcmp (envline, "PRELOAD", 7) == 0)
1753             {
1754               preloadlist = &envline[8];
1755               break;
1756             }
1757
1758           /* Which shared object shall be profiled.  */
1759           if (memcmp (envline, "PROFILE", 7) == 0 && envline[8] != '\0')
1760             GL(dl_profile) = &envline[8];
1761           break;
1762
1763         case 8:
1764           /* Do we bind early?  */
1765           if (memcmp (envline, "BIND_NOW", 8) == 0)
1766             {
1767               GL(dl_lazy) = envline[9] == '\0';
1768               break;
1769             }
1770           if (memcmp (envline, "BIND_NOT", 8) == 0)
1771             GL(dl_bind_not) = envline[9] != '\0';
1772           break;
1773
1774         case 9:
1775           /* Test whether we want to see the content of the auxiliary
1776              array passed up from the kernel.  */
1777           if (memcmp (envline, "SHOW_AUXV", 9) == 0)
1778             _dl_show_auxv ();
1779           break;
1780
1781         case 10:
1782           /* Mask for the important hardware capabilities.  */
1783           if (memcmp (envline, "HWCAP_MASK", 10) == 0)
1784             GL(dl_hwcap_mask) = __strtoul_internal (&envline[11], NULL, 0, 0);
1785           break;
1786
1787         case 11:
1788           /* Path where the binary is found.  */
1789           if (!INTUSE(__libc_enable_secure)
1790               && memcmp (envline, "ORIGIN_PATH", 11) == 0)
1791             GL(dl_origin_path) = &envline[12];
1792           break;
1793
1794         case 12:
1795           /* The library search path.  */
1796           if (memcmp (envline, "LIBRARY_PATH", 12) == 0)
1797             {
1798               library_path = &envline[13];
1799               break;
1800             }
1801
1802           /* Where to place the profiling data file.  */
1803           if (memcmp (envline, "DEBUG_OUTPUT", 12) == 0)
1804             {
1805               debug_output = &envline[13];
1806               break;
1807             }
1808
1809           if (memcmp (envline, "DYNAMIC_WEAK", 12) == 0)
1810             GL(dl_dynamic_weak) = 1;
1811           break;
1812
1813         case 14:
1814           /* Where to place the profiling data file.  */
1815           if (!INTUSE(__libc_enable_secure)
1816               && memcmp (envline, "PROFILE_OUTPUT", 14) == 0
1817               && envline[15] != '\0')
1818             GL(dl_profile_output) = &envline[15];
1819           break;
1820
1821         case 16:
1822           /* The mode of the dynamic linker can be set.  */
1823           if (memcmp (envline, "TRACE_PRELINKING", 16) == 0)
1824             {
1825               mode = trace;
1826               GL(dl_verbose) = 1;
1827               GL(dl_debug_mask) |= DL_DEBUG_PRELINK;
1828               GL(dl_trace_prelink) = &envline[17];
1829             }
1830           break;
1831
1832         case 20:
1833           /* The mode of the dynamic linker can be set.  */
1834           if (memcmp (envline, "TRACE_LOADED_OBJECTS", 20) == 0)
1835             mode = trace;
1836           break;
1837
1838           /* We might have some extra environment variable to handle.  This
1839              is tricky due to the pre-processing of the length of the name
1840              in the switch statement here.  The code here assumes that added
1841              environment variables have a different length.  */
1842 #ifdef EXTRA_LD_ENVVARS
1843           EXTRA_LD_ENVVARS
1844 #endif
1845         }
1846     }
1847
1848   /* The caller wants this information.  */
1849   *modep = mode;
1850
1851   /* Extra security for SUID binaries.  Remove all dangerous environment
1852      variables.  */
1853   if (__builtin_expect (INTUSE(__libc_enable_secure), 0))
1854     {
1855       static const char unsecure_envvars[] =
1856 #ifdef EXTRA_UNSECURE_ENVVARS
1857         EXTRA_UNSECURE_ENVVARS
1858 #endif
1859         UNSECURE_ENVVARS;
1860       const char *nextp;
1861
1862       nextp = unsecure_envvars;
1863       do
1864         {
1865           unsetenv (nextp);
1866           /* We could use rawmemchr but this need not be fast.  */
1867           nextp = (char *) (strchr) (nextp, '\0') + 1;
1868         }
1869       while (*nextp != '\0');
1870
1871       if (__access ("/etc/suid-debug", F_OK) != 0)
1872         unsetenv ("MALLOC_CHECK_");
1873     }
1874   /* If we have to run the dynamic linker in debugging mode and the
1875      LD_DEBUG_OUTPUT environment variable is given, we write the debug
1876      messages to this file.  */
1877   else if (any_debug && debug_output != NULL)
1878     {
1879 #ifdef O_NOFOLLOW
1880       const int flags = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
1881 #else
1882       const int flags = O_WRONLY | O_APPEND | O_CREAT;
1883 #endif
1884       size_t name_len = strlen (debug_output);
1885       char buf[name_len + 12];
1886       char *startp;
1887
1888       buf[name_len + 11] = '\0';
1889       startp = _itoa (__getpid (), &buf[name_len + 11], 10, 0);
1890       *--startp = '.';
1891       startp = memcpy (startp - name_len, debug_output, name_len);
1892
1893       GL(dl_debug_fd) = __open (startp, flags, DEFFILEMODE);
1894       if (GL(dl_debug_fd) == -1)
1895         /* We use standard output if opening the file failed.  */
1896         GL(dl_debug_fd) = STDOUT_FILENO;
1897     }
1898 }
1899
1900
1901 /* Print the various times we collected.  */
1902 static void
1903 print_statistics (void)
1904 {
1905 #ifndef HP_TIMING_NONAVAIL
1906   char buf[200];
1907   char *cp;
1908   char *wp;
1909
1910   /* Total time rtld used.  */
1911   if (HP_TIMING_AVAIL)
1912     {
1913       HP_TIMING_PRINT (buf, sizeof (buf), rtld_total_time);
1914       INTUSE(_dl_debug_printf) ("\nruntime linker statistics:\n"
1915                                 "  total startup time in dynamic loader: %s\n",
1916                                 buf);
1917     }
1918
1919   /* Print relocation statistics.  */
1920   if (HP_TIMING_AVAIL)
1921     {
1922       char pbuf[30];
1923       HP_TIMING_PRINT (buf, sizeof (buf), relocate_time);
1924       cp = _itoa ((1000ULL * relocate_time) / rtld_total_time,
1925                   pbuf + sizeof (pbuf), 10, 0);
1926       wp = pbuf;
1927       switch (pbuf + sizeof (pbuf) - cp)
1928         {
1929         case 3:
1930           *wp++ = *cp++;
1931         case 2:
1932           *wp++ = *cp++;
1933         case 1:
1934           *wp++ = '.';
1935           *wp++ = *cp++;
1936         }
1937       *wp = '\0';
1938       INTUSE(_dl_debug_printf) ("\
1939             time needed for relocation: %s (%s%%)\n",
1940                                 buf, pbuf);
1941     }
1942 #endif
1943   INTUSE(_dl_debug_printf) ("                 number of relocations: %lu\n",
1944                             GL(dl_num_relocations));
1945   INTUSE(_dl_debug_printf) ("      number of relocations from cache: %lu\n",
1946                             GL(dl_num_cache_relocations));
1947
1948 #ifndef HP_TIMING_NONAVAIL
1949   /* Time spend while loading the object and the dependencies.  */
1950   if (HP_TIMING_AVAIL)
1951     {
1952       char pbuf[30];
1953       HP_TIMING_PRINT (buf, sizeof (buf), load_time);
1954       cp = _itoa ((1000ULL * load_time) / rtld_total_time,
1955                   pbuf + sizeof (pbuf), 10, 0);
1956       wp = pbuf;
1957       switch (pbuf + sizeof (pbuf) - cp)
1958         {
1959         case 3:
1960           *wp++ = *cp++;
1961         case 2:
1962           *wp++ = *cp++;
1963         case 1:
1964           *wp++ = '.';
1965           *wp++ = *cp++;
1966         }
1967       *wp = '\0';
1968       INTUSE(_dl_debug_printf) ("\
1969            time needed to load objects: %s (%s%%)\n",
1970                                 buf, pbuf);
1971     }
1972 #endif
1973 }