Updated to fedora-glibc-20041006T0900
[kopensolaris-gnu/glibc.git] / elf / rtld.c
1 /* Run time dynamic linker.
2    Copyright (C) 1995-2002, 2003, 2004 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 <dlfcn.h>
22 #include <fcntl.h>
23 #include <stdbool.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <sys/mman.h>           /* Check if MAP_ANON is defined.  */
28 #include <sys/param.h>
29 #include <sys/stat.h>
30 #include <ldsodefs.h>
31 #include <stdio-common/_itoa.h>
32 #include <entry.h>
33 #include <fpu_control.h>
34 #include <hp-timing.h>
35 #include <bits/libc-lock.h>
36 #include "dynamic-link.h"
37 #include "dl-librecon.h"
38 #include <unsecvars.h>
39 #include <dl-cache.h>
40 #include <dl-procinfo.h>
41 #include <tls.h>
42
43 #include <assert.h>
44
45 /* Avoid PLT use for our local calls at startup.  */
46 extern __typeof (__mempcpy) __mempcpy attribute_hidden;
47
48 /* GCC has mental blocks about _exit.  */
49 extern __typeof (_exit) exit_internal asm ("_exit") attribute_hidden;
50 #define _exit exit_internal
51
52 /* Helper function to handle errors while resolving symbols.  */
53 static void print_unresolved (int errcode, const char *objname,
54                               const char *errsting);
55
56 /* Helper function to handle errors when a version is missing.  */
57 static void print_missing_version (int errcode, const char *objname,
58                                    const char *errsting);
59
60 /* Print the various times we collected.  */
61 static void print_statistics (hp_timing_t *total_timep);
62
63 /* This is a list of all the modes the dynamic loader can be in.  */
64 enum mode { normal, list, verify, trace };
65
66 /* Process all environments variables the dynamic linker must recognize.
67    Since all of them start with `LD_' we are a bit smarter while finding
68    all the entries.  */
69 static void process_envvars (enum mode *modep);
70
71 int _dl_argc attribute_relro attribute_hidden;
72 #ifdef DL_ARGV_NOT_RELRO
73 char **_dl_argv = NULL;
74 #else
75 char **_dl_argv attribute_relro = NULL;
76 #endif
77 INTDEF(_dl_argv)
78
79 /* Nonzero if we were run directly.  */
80 unsigned int _dl_skip_args attribute_relro attribute_hidden;
81
82 #ifndef HAVE_INLINED_SYSCALLS
83 /* Set nonzero during loading and initialization of executable and
84    libraries, cleared before the executable's entry point runs.  This
85    must not be initialized to nonzero, because the unused dynamic
86    linker loaded in for libc.so's "ld.so.1" dep will provide the
87    definition seen by libc.so's initializer; that value must be zero,
88    and will be since that dynamic linker's _dl_start and dl_main will
89    never be called.  */
90 int _dl_starting_up = 0;
91 INTVARDEF(_dl_starting_up)
92 #endif
93
94 /* This is the structure which defines all variables global to ld.so
95    (except those which cannot be added for some reason).  */
96 struct rtld_global _rtld_global =
97   {
98     /* Default presumption without further information is executable stack.  */
99     ._dl_stack_flags = PF_R|PF_W|PF_X,
100 #ifdef _LIBC_REENTRANT
101     ._dl_load_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER
102 #endif
103   };
104 /* If we would use strong_alias here the compiler would see a
105    non-hidden definition.  This would undo the effect of the previous
106    declaration.  So spell out was strong_alias does plus add the
107    visibility attribute.  */
108 extern struct rtld_global _rtld_local
109     __attribute__ ((alias ("_rtld_global"), visibility ("hidden")));
110
111
112 /* This variable is similar to _rtld_local, but all values are
113    read-only after relocation.  */
114 struct rtld_global_ro _rtld_global_ro attribute_relro =
115   {
116     /* Get architecture specific initializer.  */
117 #include <dl-procinfo.c>
118 #ifdef NEED_DL_SYSINFO
119     ._dl_sysinfo = DL_SYSINFO_DEFAULT,
120 #endif
121     ._dl_debug_fd = STDERR_FILENO,
122     ._dl_use_load_bias = -2,
123     ._dl_correct_cache_id = _DL_CACHE_DEFAULT_ID,
124     ._dl_hwcap_mask = HWCAP_IMPORTANT,
125     ._dl_lazy = 1,
126     ._dl_fpu_control = _FPU_DEFAULT,
127
128     /* Function pointers.  */
129     ._dl_get_origin = _dl_get_origin,
130     ._dl_dst_count = _dl_dst_count,
131     ._dl_dst_substitute = _dl_dst_substitute,
132     ._dl_map_object = _dl_map_object,
133     ._dl_map_object_deps = _dl_map_object_deps,
134     ._dl_relocate_object = _dl_relocate_object,
135     ._dl_check_map_versions = _dl_check_map_versions,
136     ._dl_init = _dl_init,
137     ._dl_debug_state = _dl_debug_state,
138 #ifndef MAP_COPY
139     ._dl_unload_cache = _dl_unload_cache,
140 #endif
141     ._dl_debug_printf = _dl_debug_printf,
142     ._dl_catch_error = _dl_catch_error,
143     ._dl_signal_error = _dl_signal_error,
144     ._dl_start_profile = _dl_start_profile,
145     ._dl_mcount = _dl_mcount_internal,
146     ._dl_lookup_symbol_x = _dl_lookup_symbol_x,
147     ._dl_check_caller = _dl_check_caller
148   };
149 /* If we would use strong_alias here the compiler would see a
150    non-hidden definition.  This would undo the effect of the previous
151    declaration.  So spell out was strong_alias does plus add the
152    visibility attribute.  */
153 extern struct rtld_global_ro _rtld_local_ro
154     __attribute__ ((alias ("_rtld_global_ro"), visibility ("hidden")));
155
156
157 static void dl_main (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
158                      ElfW(Addr) *user_entry);
159
160 /* These two variables cannot be moved into .data.rel.ro.  */
161 static struct libname_list _dl_rtld_libname;
162 static struct libname_list _dl_rtld_libname2;
163
164 /* We expect less than a second for relocation.  */
165 #ifdef HP_SMALL_TIMING_AVAIL
166 # undef HP_TIMING_AVAIL
167 # define HP_TIMING_AVAIL HP_SMALL_TIMING_AVAIL
168 #endif
169
170 /* Variable for statistics.  */
171 #ifndef HP_TIMING_NONAVAIL
172 static hp_timing_t relocate_time;
173 static hp_timing_t load_time attribute_relro;
174 static hp_timing_t start_time attribute_relro;
175 #endif
176
177 /* Additional definitions needed by TLS initialization.  */
178 #ifdef TLS_INIT_HELPER
179 TLS_INIT_HELPER
180 #endif
181
182 /* Helper function for syscall implementation.  */
183 #ifdef DL_SYSINFO_IMPLEMENTATION
184 DL_SYSINFO_IMPLEMENTATION
185 #endif
186
187 /* Before ld.so is relocated we must not access variables which need
188    relocations.  This means variables which are exported.  Variables
189    declared as static are fine.  If we can mark a variable hidden this
190    is fine, too.  The latter is important here.  We can avoid setting
191    up a temporary link map for ld.so if we can mark _rtld_global as
192    hidden.  */
193 #if defined PI_STATIC_AND_HIDDEN && defined HAVE_HIDDEN \
194     && defined HAVE_VISIBILITY_ATTRIBUTE
195 # define DONT_USE_BOOTSTRAP_MAP 1
196 #endif
197
198 #ifdef DONT_USE_BOOTSTRAP_MAP
199 static ElfW(Addr) _dl_start_final (void *arg);
200 #else
201 struct dl_start_final_info
202 {
203   struct link_map l;
204 #if !defined HP_TIMING_NONAVAIL && HP_TIMING_INLINE
205   hp_timing_t start_time;
206 #endif
207 };
208 static ElfW(Addr) _dl_start_final (void *arg,
209                                    struct dl_start_final_info *info);
210 #endif
211
212 /* These defined magically in the linker script.  */
213 extern char _begin[] attribute_hidden;
214 extern char _etext[] attribute_hidden;
215 extern char _end[] attribute_hidden;
216
217
218 #ifdef RTLD_START
219 RTLD_START
220 #else
221 # error "sysdeps/MACHINE/dl-machine.h fails to define RTLD_START"
222 #endif
223
224 #ifndef VALIDX
225 # define VALIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
226                       + DT_EXTRANUM + DT_VALTAGIDX (tag))
227 #endif
228 #ifndef ADDRIDX
229 # define ADDRIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
230                        + DT_EXTRANUM + DT_VALNUM + DT_ADDRTAGIDX (tag))
231 #endif
232
233 /* This is the second half of _dl_start (below).  It can be inlined safely
234    under DONT_USE_BOOTSTRAP_MAP, where it is careful not to make any GOT
235    references.  When the tools don't permit us to avoid using a GOT entry
236    for _dl_rtld_global (no attribute_hidden support), we must make sure
237    this function is not inlined (see below).  */
238
239 #ifdef DONT_USE_BOOTSTRAP_MAP
240 static inline ElfW(Addr) __attribute__ ((always_inline))
241 _dl_start_final (void *arg)
242 #else
243 static ElfW(Addr) __attribute__ ((noinline))
244 _dl_start_final (void *arg, struct dl_start_final_info *info)
245 #endif
246 {
247   ElfW(Addr) start_addr;
248
249   if (HP_TIMING_AVAIL)
250     {
251       /* If it hasn't happen yet record the startup time.  */
252       if (! HP_TIMING_INLINE)
253         HP_TIMING_NOW (start_time);
254 #if !defined DONT_USE_BOOTSTRAP_MAP && !defined HP_TIMING_NONAVAIL
255       else
256         start_time = info->start_time;
257 #endif
258
259       /* Initialize the timing functions.  */
260       HP_TIMING_DIFF_INIT ();
261     }
262
263   /* Transfer data about ourselves to the permanent link_map structure.  */
264 #ifndef DONT_USE_BOOTSTRAP_MAP
265   GL(dl_rtld_map).l_addr = info->l.l_addr;
266   GL(dl_rtld_map).l_ld = info->l.l_ld;
267   memcpy (GL(dl_rtld_map).l_info, info->l.l_info,
268           sizeof GL(dl_rtld_map).l_info);
269   GL(dl_rtld_map).l_mach = info->l.l_mach;
270 #endif
271   _dl_setup_hash (&GL(dl_rtld_map));
272   GL(dl_rtld_map).l_opencount = 1;
273   GL(dl_rtld_map).l_map_start = (ElfW(Addr)) _begin;
274   GL(dl_rtld_map).l_map_end = (ElfW(Addr)) _end;
275   GL(dl_rtld_map).l_text_end = (ElfW(Addr)) _etext;
276   /* Copy the TLS related data if necessary.  */
277 #if USE_TLS && !defined DONT_USE_BOOTSTRAP_MAP
278 # if USE___THREAD
279   assert (info->l.l_tls_modid != 0);
280   GL(dl_rtld_map).l_tls_blocksize = info->l.l_tls_blocksize;
281   GL(dl_rtld_map).l_tls_align = info->l.l_tls_align;
282   GL(dl_rtld_map).l_tls_firstbyte_offset = info->l.l_tls_firstbyte_offset;
283   GL(dl_rtld_map).l_tls_initimage_size = info->l.l_tls_initimage_size;
284   GL(dl_rtld_map).l_tls_initimage = info->l.l_tls_initimage;
285   GL(dl_rtld_map).l_tls_offset = info->l.l_tls_offset;
286   GL(dl_rtld_map).l_tls_modid = 1;
287 # else
288   assert (info->l.l_tls_modid == 0);
289 #  if NO_TLS_OFFSET != 0
290   GL(dl_rtld_map).l_tls_offset = NO_TLS_OFFSET;
291 #  endif
292 # endif
293
294 #endif
295
296 #if HP_TIMING_AVAIL
297   HP_TIMING_NOW (GL(dl_cpuclock_offset));
298 #endif
299
300   /* Initialize the stack end variable.  */
301   __libc_stack_end = __builtin_frame_address (0);
302
303   /* Call the OS-dependent function to set up life so we can do things like
304      file access.  It will call `dl_main' (below) to do all the real work
305      of the dynamic linker, and then unwind our frame and run the user
306      entry point on the same stack we entered on.  */
307   start_addr = _dl_sysdep_start (arg, &dl_main);
308
309 #ifndef HP_TIMING_NONAVAIL
310   hp_timing_t rtld_total_time;
311   if (HP_TIMING_AVAIL)
312     {
313       hp_timing_t end_time;
314
315       /* Get the current time.  */
316       HP_TIMING_NOW (end_time);
317
318       /* Compute the difference.  */
319       HP_TIMING_DIFF (rtld_total_time, start_time, end_time);
320     }
321 #endif
322
323   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS, 0))
324     {
325 #ifndef HP_TIMING_NONAVAIL
326       print_statistics (&rtld_total_time);
327 #else
328       print_statistics (NULL);
329 #endif
330     }
331
332   return start_addr;
333 }
334
335 static ElfW(Addr) __attribute_used__ internal_function
336 _dl_start (void *arg)
337 {
338 #ifdef DONT_USE_BOOTSTRAP_MAP
339 # define bootstrap_map GL(dl_rtld_map)
340 #else
341   struct dl_start_final_info info;
342 # define bootstrap_map info.l
343 #endif
344
345   /* This #define produces dynamic linking inline functions for
346      bootstrap relocation instead of general-purpose relocation.  */
347 #define RTLD_BOOTSTRAP
348 #define RESOLVE_MAP(sym, version, flags) \
349   ((*(sym))->st_shndx == SHN_UNDEF ? 0 : &bootstrap_map)
350 #define RESOLVE(sym, version, flags) \
351   ((*(sym))->st_shndx == SHN_UNDEF ? 0 : bootstrap_map.l_addr)
352 #include "dynamic-link.h"
353
354   if (HP_TIMING_INLINE && HP_TIMING_AVAIL)
355 #ifdef DONT_USE_BOOTSTRAP_MAP
356     HP_TIMING_NOW (start_time);
357 #else
358     HP_TIMING_NOW (info.start_time);
359 #endif
360
361   /* Partly clean the `bootstrap_map' structure up.  Don't use
362      `memset' since it might not be built in or inlined and we cannot
363      make function calls at this point.  Use '__builtin_memset' if we
364      know it is available.  We do not have to clear the memory if we
365      do not have to use the temporary bootstrap_map.  Global variables
366      are initialized to zero by default.  */
367 #ifndef DONT_USE_BOOTSTRAP_MAP
368 # ifdef HAVE_BUILTIN_MEMSET
369   __builtin_memset (bootstrap_map.l_info, '\0', sizeof (bootstrap_map.l_info));
370 # else
371   for (size_t cnt = 0;
372        cnt < sizeof (bootstrap_map.l_info) / sizeof (bootstrap_map.l_info[0]);
373        ++cnt)
374     bootstrap_map.l_info[cnt] = 0;
375 # endif
376 #endif
377
378   /* Figure out the run-time load address of the dynamic linker itself.  */
379   bootstrap_map.l_addr = elf_machine_load_address ();
380
381   /* Read our own dynamic section and fill in the info array.  */
382   bootstrap_map.l_ld = (void *) bootstrap_map.l_addr + elf_machine_dynamic ();
383   elf_get_dynamic_info (&bootstrap_map, NULL);
384
385 #if defined USE_TLS && NO_TLS_OFFSET != 0
386   bootstrap_map.l_tls_offset = NO_TLS_OFFSET;
387 #endif
388
389   /* Get the dynamic linker's own program header.  First we need the ELF
390      file header.  The `_begin' symbol created by the linker script points
391      to it.  When we have something like GOTOFF relocs, we can use a plain
392      reference to find the runtime address.  Without that, we have to rely
393      on the `l_addr' value, which is not the value we want when prelinked.  */
394 #if USE___THREAD
395   dtv_t initdtv[3];
396   ElfW(Ehdr) *ehdr
397 # ifdef DONT_USE_BOOTSTRAP_MAP
398     = (ElfW(Ehdr) *) &_begin;
399 # else
400 #  error This will not work with prelink.
401     = (ElfW(Ehdr) *) bootstrap_map.l_addr;
402 # endif
403   ElfW(Phdr) *phdr = (ElfW(Phdr) *) ((void *) ehdr + ehdr->e_phoff);
404   size_t cnt = ehdr->e_phnum;   /* PT_TLS is usually the last phdr.  */
405   while (cnt-- > 0)
406     if (phdr[cnt].p_type == PT_TLS)
407       {
408         void *tlsblock;
409         size_t max_align = MAX (TLS_INIT_TCB_ALIGN, phdr[cnt].p_align);
410         char *p;
411
412         bootstrap_map.l_tls_blocksize = phdr[cnt].p_memsz;
413         bootstrap_map.l_tls_align = phdr[cnt].p_align;
414         if (phdr[cnt].p_align == 0)
415           bootstrap_map.l_tls_firstbyte_offset = 0;
416         else
417           bootstrap_map.l_tls_firstbyte_offset = (phdr[cnt].p_vaddr
418                                                   & (phdr[cnt].p_align - 1));
419         assert (bootstrap_map.l_tls_blocksize != 0);
420         bootstrap_map.l_tls_initimage_size = phdr[cnt].p_filesz;
421         bootstrap_map.l_tls_initimage = (void *) (bootstrap_map.l_addr
422                                                   + phdr[cnt].p_vaddr);
423
424         /* We can now allocate the initial TLS block.  This can happen
425            on the stack.  We'll get the final memory later when we
426            know all about the various objects loaded at startup
427            time.  */
428 # if TLS_TCB_AT_TP
429         tlsblock = alloca (roundup (bootstrap_map.l_tls_blocksize,
430                                     TLS_INIT_TCB_ALIGN)
431                            + TLS_INIT_TCB_SIZE
432                            + max_align);
433 # elif TLS_DTV_AT_TP
434         tlsblock = alloca (roundup (TLS_INIT_TCB_SIZE,
435                                     bootstrap_map.l_tls_align)
436                            + bootstrap_map.l_tls_blocksize
437                            + max_align);
438 # else
439         /* In case a model with a different layout for the TCB and DTV
440            is defined add another #elif here and in the following #ifs.  */
441 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
442 # endif
443         /* Align the TLS block.  */
444         tlsblock = (void *) (((uintptr_t) tlsblock + max_align - 1)
445                              & ~(max_align - 1));
446
447         /* Initialize the dtv.  [0] is the length, [1] the generation
448            counter.  */
449         initdtv[0].counter = 1;
450         initdtv[1].counter = 0;
451
452         /* Initialize the TLS block.  */
453 # if TLS_TCB_AT_TP
454         initdtv[2].pointer = tlsblock;
455 # elif TLS_DTV_AT_TP
456         bootstrap_map.l_tls_offset = roundup (TLS_INIT_TCB_SIZE,
457                                               bootstrap_map.l_tls_align);
458         initdtv[2].pointer = (char *) tlsblock + bootstrap_map.l_tls_offset;
459 # else
460 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
461 # endif
462         p = __mempcpy (initdtv[2].pointer, bootstrap_map.l_tls_initimage,
463                        bootstrap_map.l_tls_initimage_size);
464 # ifdef HAVE_BUILTIN_MEMSET
465         __builtin_memset (p, '\0', (bootstrap_map.l_tls_blocksize
466                                     - bootstrap_map.l_tls_initimage_size));
467 # else
468         {
469           size_t remaining = (bootstrap_map.l_tls_blocksize
470                               - bootstrap_map.l_tls_initimage_size);
471           while (remaining-- > 0)
472             *p++ = '\0';
473         }
474 #endif
475
476         /* Install the pointer to the dtv.  */
477
478         /* Initialize the thread pointer.  */
479 # if TLS_TCB_AT_TP
480         bootstrap_map.l_tls_offset
481           = roundup (bootstrap_map.l_tls_blocksize, TLS_INIT_TCB_ALIGN);
482
483         INSTALL_DTV ((char *) tlsblock + bootstrap_map.l_tls_offset,
484                      initdtv);
485
486         const char *lossage = TLS_INIT_TP ((char *) tlsblock
487                                            + bootstrap_map.l_tls_offset, 0);
488 # elif TLS_DTV_AT_TP
489         INSTALL_DTV (tlsblock, initdtv);
490         const char *lossage = TLS_INIT_TP (tlsblock, 0);
491 # else
492 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
493 # endif
494         if (__builtin_expect (lossage != NULL, 0))
495           _dl_fatal_printf ("cannot set up thread-local storage: %s\n",
496                             lossage);
497
498         /* So far this is module number one.  */
499         bootstrap_map.l_tls_modid = 1;
500
501         /* There can only be one PT_TLS entry.  */
502         break;
503       }
504 #endif  /* USE___THREAD */
505
506 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
507   ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
508 #endif
509
510   if (bootstrap_map.l_addr || ! bootstrap_map.l_info[VALIDX(DT_GNU_PRELINKED)])
511     {
512       /* Relocate ourselves so we can do normal function calls and
513          data access using the global offset table.  */
514
515       ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, 0);
516     }
517
518   /* Please note that we don't allow profiling of this object and
519      therefore need not test whether we have to allocate the array
520      for the relocation results (as done in dl-reloc.c).  */
521
522   /* Now life is sane; we can call functions and access global data.
523      Set up to use the operating system facilities, and find out from
524      the operating system's program loader where to find the program
525      header table in core.  Put the rest of _dl_start into a separate
526      function, that way the compiler cannot put accesses to the GOT
527      before ELF_DYNAMIC_RELOCATE.  */
528   {
529 #ifdef DONT_USE_BOOTSTRAP_MAP
530     ElfW(Addr) entry = _dl_start_final (arg);
531 #else
532     ElfW(Addr) entry = _dl_start_final (arg, &info);
533 #endif
534
535 #ifndef ELF_MACHINE_START_ADDRESS
536 # define ELF_MACHINE_START_ADDRESS(map, start) (start)
537 #endif
538
539     return ELF_MACHINE_START_ADDRESS (GL(dl_loaded), entry);
540   }
541 }
542
543
544
545 /* Now life is peachy; we can do all normal operations.
546    On to the real work.  */
547
548 /* Some helper functions.  */
549
550 /* Arguments to relocate_doit.  */
551 struct relocate_args
552 {
553   struct link_map *l;
554   int lazy;
555 };
556
557 struct map_args
558 {
559   /* Argument to map_doit.  */
560   char *str;
561   struct link_map *loader;
562   int is_preloaded;
563   int mode;
564   /* Return value of map_doit.  */
565   struct link_map *map;
566 };
567
568 /* Arguments to version_check_doit.  */
569 struct version_check_args
570 {
571   int doexit;
572   int dotrace;
573 };
574
575 static void
576 relocate_doit (void *a)
577 {
578   struct relocate_args *args = (struct relocate_args *) a;
579
580   _dl_relocate_object (args->l, args->l->l_scope, args->lazy, 0);
581 }
582
583 static void
584 map_doit (void *a)
585 {
586   struct map_args *args = (struct map_args *) a;
587   args->map = _dl_map_object (args->loader, args->str,
588                               args->is_preloaded, lt_library, 0, args->mode);
589 }
590
591 static void
592 version_check_doit (void *a)
593 {
594   struct version_check_args *args = (struct version_check_args *) a;
595   if (_dl_check_all_versions (GL(dl_loaded), 1, args->dotrace) && args->doexit)
596     /* We cannot start the application.  Abort now.  */
597     _exit (1);
598 }
599
600
601 static inline struct link_map *
602 find_needed (const char *name)
603 {
604   unsigned int n = GL(dl_loaded)->l_searchlist.r_nlist;
605
606   while (n-- > 0)
607     if (_dl_name_match_p (name, GL(dl_loaded)->l_searchlist.r_list[n]))
608       return GL(dl_loaded)->l_searchlist.r_list[n];
609
610   /* Should never happen.  */
611   return NULL;
612 }
613
614 static int
615 match_version (const char *string, struct link_map *map)
616 {
617   const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
618   ElfW(Verdef) *def;
619
620 #define VERDEFTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERDEF))
621   if (map->l_info[VERDEFTAG] == NULL)
622     /* The file has no symbol versioning.  */
623     return 0;
624
625   def = (ElfW(Verdef) *) ((char *) map->l_addr
626                           + map->l_info[VERDEFTAG]->d_un.d_ptr);
627   while (1)
628     {
629       ElfW(Verdaux) *aux = (ElfW(Verdaux) *) ((char *) def + def->vd_aux);
630
631       /* Compare the version strings.  */
632       if (strcmp (string, strtab + aux->vda_name) == 0)
633         /* Bingo!  */
634         return 1;
635
636       /* If no more definitions we failed to find what we want.  */
637       if (def->vd_next == 0)
638         break;
639
640       /* Next definition.  */
641       def = (ElfW(Verdef) *) ((char *) def + def->vd_next);
642     }
643
644   return 0;
645 }
646
647 #ifdef _LIBC_REENTRANT
648 /* _dl_error_catch_tsd points to this for the single-threaded case.
649    It's reset by the thread library for multithreaded programs.  */
650 void ** __attribute__ ((const))
651 _dl_initial_error_catch_tsd (void)
652 {
653   static void *data;
654   return &data;
655 }
656 #endif
657
658 #if defined SHARED && defined _LIBC_REENTRANT \
659     && defined __rtld_lock_default_lock_recursive
660 static void rtld_lock_default_lock_recursive (void *lock)
661 {
662   __rtld_lock_default_lock_recursive (lock);
663 }
664
665 static void rtld_lock_default_unlock_recursive (void *lock)
666 {
667   __rtld_lock_default_unlock_recursive (lock);
668 }
669 #endif
670
671
672 /* The library search path.  */
673 static const char *library_path attribute_relro;
674 /* The list preloaded objects.  */
675 static const char *preloadlist attribute_relro;
676 /* Nonzero if information about versions has to be printed.  */
677 static int version_info attribute_relro;
678
679 static void
680 dl_main (const ElfW(Phdr) *phdr,
681          ElfW(Word) phnum,
682          ElfW(Addr) *user_entry)
683 {
684   const ElfW(Phdr) *ph;
685   enum mode mode;
686   struct link_map **preloads;
687   unsigned int npreloads;
688   size_t file_size;
689   char *file;
690   bool has_interp = false;
691   unsigned int i;
692   bool prelinked = false;
693   bool rtld_is_main = false;
694 #ifndef HP_TIMING_NONAVAIL
695   hp_timing_t start;
696   hp_timing_t stop;
697   hp_timing_t diff;
698 #endif
699 #ifdef USE_TLS
700   void *tcbp;
701 #endif
702
703 #ifdef _LIBC_REENTRANT
704   /* Explicit initialization since the reloc would just be more work.  */
705   GL(dl_error_catch_tsd) = &_dl_initial_error_catch_tsd;
706 #endif
707
708 #ifdef USE_TLS
709   GL(dl_init_static_tls) = &_dl_nothread_init_static_tls;
710 #endif
711
712 #if defined SHARED && defined _LIBC_REENTRANT \
713     && defined __rtld_lock_default_lock_recursive
714   GL(dl_rtld_lock_recursive) = rtld_lock_default_lock_recursive;
715   GL(dl_rtld_unlock_recursive) = rtld_lock_default_unlock_recursive;
716 #endif
717
718   /* The explicit initialization here is cheaper than processing the reloc
719      in the _rtld_local definition's initializer.  */
720   GL(dl_make_stack_executable_hook) = &_dl_make_stack_executable;
721
722   /* Process the environment variable which control the behaviour.  */
723   process_envvars (&mode);
724
725 #ifndef HAVE_INLINED_SYSCALLS
726   /* Set up a flag which tells we are just starting.  */
727   INTUSE(_dl_starting_up) = 1;
728 #endif
729
730   if (*user_entry == (ElfW(Addr)) ENTRY_POINT)
731     {
732       /* Ho ho.  We are not the program interpreter!  We are the program
733          itself!  This means someone ran ld.so as a command.  Well, that
734          might be convenient to do sometimes.  We support it by
735          interpreting the args like this:
736
737          ld.so PROGRAM ARGS...
738
739          The first argument is the name of a file containing an ELF
740          executable we will load and run with the following arguments.
741          To simplify life here, PROGRAM is searched for using the
742          normal rules for shared objects, rather than $PATH or anything
743          like that.  We just load it and use its entry point; we don't
744          pay attention to its PT_INTERP command (we are the interpreter
745          ourselves).  This is an easy way to test a new ld.so before
746          installing it.  */
747       rtld_is_main = true;
748
749       /* Note the place where the dynamic linker actually came from.  */
750       GL(dl_rtld_map).l_name = rtld_progname;
751
752       while (_dl_argc > 1)
753         if (! strcmp (INTUSE(_dl_argv)[1], "--list"))
754           {
755             mode = list;
756             GLRO(dl_lazy) = -1; /* This means do no dependency analysis.  */
757
758             ++_dl_skip_args;
759             --_dl_argc;
760             ++INTUSE(_dl_argv);
761           }
762         else if (! strcmp (INTUSE(_dl_argv)[1], "--verify"))
763           {
764             mode = verify;
765
766             ++_dl_skip_args;
767             --_dl_argc;
768             ++INTUSE(_dl_argv);
769           }
770         else if (! strcmp (INTUSE(_dl_argv)[1], "--library-path")
771                  && _dl_argc > 2)
772           {
773             library_path = INTUSE(_dl_argv)[2];
774
775             _dl_skip_args += 2;
776             _dl_argc -= 2;
777             INTUSE(_dl_argv) += 2;
778           }
779         else if (! strcmp (INTUSE(_dl_argv)[1], "--inhibit-rpath")
780                  && _dl_argc > 2)
781           {
782             GLRO(dl_inhibit_rpath) = INTUSE(_dl_argv)[2];
783
784             _dl_skip_args += 2;
785             _dl_argc -= 2;
786             INTUSE(_dl_argv) += 2;
787           }
788         else
789           break;
790
791       /* If we have no further argument the program was called incorrectly.
792          Grant the user some education.  */
793       if (_dl_argc < 2)
794         _dl_fatal_printf ("\
795 Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\
796 You have invoked `ld.so', the helper program for shared library executables.\n\
797 This program usually lives in the file `/lib/ld.so', and special directives\n\
798 in executable files using ELF shared libraries tell the system's program\n\
799 loader to load the helper program from this file.  This helper program loads\n\
800 the shared libraries needed by the program executable, prepares the program\n\
801 to run, and runs it.  You may invoke this helper program directly from the\n\
802 command line to load and run an ELF executable file; this is like executing\n\
803 that file itself, but always uses this helper program from the file you\n\
804 specified, instead of the helper program file specified in the executable\n\
805 file you run.  This is mostly of use for maintainers to test new versions\n\
806 of this helper program; chances are you did not intend to run this program.\n\
807 \n\
808   --list                list all dependencies and how they are resolved\n\
809   --verify              verify that given object really is a dynamically linked\n\
810                         object we can handle\n\
811   --library-path PATH   use given PATH instead of content of the environment\n\
812                         variable LD_LIBRARY_PATH\n\
813   --inhibit-rpath LIST  ignore RUNPATH and RPATH information in object names\n\
814                         in LIST\n");
815
816       ++_dl_skip_args;
817       --_dl_argc;
818       ++INTUSE(_dl_argv);
819
820       /* Initialize the data structures for the search paths for shared
821          objects.  */
822       _dl_init_paths (library_path);
823
824       /* The initialization of _dl_stack_flags done below assumes the
825          executable's PT_GNU_STACK may have been honored by the kernel, and
826          so a PT_GNU_STACK with PF_X set means the stack started out with
827          execute permission.  However, this is not really true if the
828          dynamic linker is the executable the kernel loaded.  For this
829          case, we must reinitialize _dl_stack_flags to match the dynamic
830          linker itself.  If the dynamic linker was built with a
831          PT_GNU_STACK, then the kernel may have loaded us with a
832          nonexecutable stack that we will have to make executable when we
833          load the program below unless it has a PT_GNU_STACK indicating
834          nonexecutable stack is ok.  */
835
836       for (ph = phdr; ph < &phdr[phnum]; ++ph)
837         if (ph->p_type == PT_GNU_STACK)
838           {
839             GL(dl_stack_flags) = ph->p_flags;
840             break;
841           }
842
843       if (__builtin_expect (mode, normal) == verify)
844         {
845           const char *objname;
846           const char *err_str = NULL;
847           struct map_args args;
848
849           args.str = rtld_progname;
850           args.loader = NULL;
851           args.is_preloaded = 0;
852           args.mode = __RTLD_OPENEXEC;
853           (void) _dl_catch_error (&objname, &err_str, map_doit, &args);
854           if (__builtin_expect (err_str != NULL, 0))
855             /* We don't free the returned string, the programs stops
856                anyway.  */
857             _exit (EXIT_FAILURE);
858         }
859       else
860         {
861           HP_TIMING_NOW (start);
862           _dl_map_object (NULL, rtld_progname, 0, lt_library, 0,
863                           __RTLD_OPENEXEC);
864           HP_TIMING_NOW (stop);
865
866           HP_TIMING_DIFF (load_time, start, stop);
867         }
868
869       phdr = GL(dl_loaded)->l_phdr;
870       phnum = GL(dl_loaded)->l_phnum;
871       /* We overwrite here a pointer to a malloc()ed string.  But since
872          the malloc() implementation used at this point is the dummy
873          implementations which has no real free() function it does not
874          makes sense to free the old string first.  */
875       GL(dl_loaded)->l_name = (char *) "";
876       *user_entry = GL(dl_loaded)->l_entry;
877     }
878   else
879     {
880       /* Create a link_map for the executable itself.
881          This will be what dlopen on "" returns.  */
882       _dl_new_object ((char *) "", "", lt_executable, NULL, 0);
883       if (GL(dl_loaded) == NULL)
884         _dl_fatal_printf ("cannot allocate memory for link map\n");
885       GL(dl_loaded)->l_phdr = phdr;
886       GL(dl_loaded)->l_phnum = phnum;
887       GL(dl_loaded)->l_entry = *user_entry;
888
889       /* At this point we are in a bit of trouble.  We would have to
890          fill in the values for l_dev and l_ino.  But in general we
891          do not know where the file is.  We also do not handle AT_EXECFD
892          even if it would be passed up.
893
894          We leave the values here defined to 0.  This is normally no
895          problem as the program code itself is normally no shared
896          object and therefore cannot be loaded dynamically.  Nothing
897          prevent the use of dynamic binaries and in these situations
898          we might get problems.  We might not be able to find out
899          whether the object is already loaded.  But since there is no
900          easy way out and because the dynamic binary must also not
901          have an SONAME we ignore this program for now.  If it becomes
902          a problem we can force people using SONAMEs.  */
903
904       /* We delay initializing the path structure until we got the dynamic
905          information for the program.  */
906     }
907
908   GL(dl_loaded)->l_map_end = 0;
909   GL(dl_loaded)->l_text_end = 0;
910   /* Perhaps the executable has no PT_LOAD header entries at all.  */
911   GL(dl_loaded)->l_map_start = ~0;
912   /* We opened the file, account for it.  */
913   ++GL(dl_loaded)->l_opencount;
914
915   /* Scan the program header table for the dynamic section.  */
916   for (ph = phdr; ph < &phdr[phnum]; ++ph)
917     switch (ph->p_type)
918       {
919       case PT_PHDR:
920         /* Find out the load address.  */
921         GL(dl_loaded)->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
922         break;
923       case PT_DYNAMIC:
924         /* This tells us where to find the dynamic section,
925            which tells us everything we need to do.  */
926         GL(dl_loaded)->l_ld = (void *) GL(dl_loaded)->l_addr + ph->p_vaddr;
927         break;
928       case PT_INTERP:
929         /* This "interpreter segment" was used by the program loader to
930            find the program interpreter, which is this program itself, the
931            dynamic linker.  We note what name finds us, so that a future
932            dlopen call or DT_NEEDED entry, for something that wants to link
933            against the dynamic linker as a shared library, will know that
934            the shared object is already loaded.  */
935         _dl_rtld_libname.name = ((const char *) GL(dl_loaded)->l_addr
936                                  + ph->p_vaddr);
937         /* _dl_rtld_libname.next = NULL;        Already zero.  */
938         GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
939
940         /* Ordinarilly, we would get additional names for the loader from
941            our DT_SONAME.  This can't happen if we were actually linked as
942            a static executable (detect this case when we have no DYNAMIC).
943            If so, assume the filename component of the interpreter path to
944            be our SONAME, and add it to our name list.  */
945         if (GL(dl_rtld_map).l_ld == NULL)
946           {
947             const char *p = NULL;
948             const char *cp = _dl_rtld_libname.name;
949
950             /* Find the filename part of the path.  */
951             while (*cp != '\0')
952               if (*cp++ == '/')
953                 p = cp;
954
955             if (p != NULL)
956               {
957                 _dl_rtld_libname2.name = p;
958                 /* _dl_rtld_libname2.next = NULL;  Already zero.  */
959                 _dl_rtld_libname.next = &_dl_rtld_libname2;
960               }
961           }
962
963         has_interp = true;
964         break;
965       case PT_LOAD:
966         {
967           ElfW(Addr) mapstart;
968           ElfW(Addr) allocend;
969
970           /* Remember where the main program starts in memory.  */
971           mapstart = (GL(dl_loaded)->l_addr
972                       + (ph->p_vaddr & ~(ph->p_align - 1)));
973           if (GL(dl_loaded)->l_map_start > mapstart)
974             GL(dl_loaded)->l_map_start = mapstart;
975
976           /* Also where it ends.  */
977           allocend = GL(dl_loaded)->l_addr + ph->p_vaddr + ph->p_memsz;
978           if (GL(dl_loaded)->l_map_end < allocend)
979             GL(dl_loaded)->l_map_end = allocend;
980           if ((ph->p_flags & PF_X) && allocend > GL(dl_loaded)->l_text_end)
981             GL(dl_loaded)->l_text_end = allocend;
982         }
983         break;
984 #ifdef USE_TLS
985       case PT_TLS:
986         if (ph->p_memsz > 0)
987           {
988             /* Note that in the case the dynamic linker we duplicate work
989                here since we read the PT_TLS entry already in
990                _dl_start_final.  But the result is repeatable so do not
991                check for this special but unimportant case.  */
992             GL(dl_loaded)->l_tls_blocksize = ph->p_memsz;
993             GL(dl_loaded)->l_tls_align = ph->p_align;
994             if (ph->p_align == 0)
995               GL(dl_loaded)->l_tls_firstbyte_offset = 0;
996             else
997               GL(dl_loaded)->l_tls_firstbyte_offset = (ph->p_vaddr
998                                                        & (ph->p_align - 1));
999             GL(dl_loaded)->l_tls_initimage_size = ph->p_filesz;
1000             GL(dl_loaded)->l_tls_initimage = (void *) ph->p_vaddr;
1001
1002             /* This image gets the ID one.  */
1003             GL(dl_tls_max_dtv_idx) = GL(dl_loaded)->l_tls_modid = 1;
1004           }
1005         break;
1006 #endif
1007       case PT_GNU_STACK:
1008         GL(dl_stack_flags) = ph->p_flags;
1009         break;
1010
1011       case PT_GNU_RELRO:
1012         GL(dl_loaded)->l_relro_addr = ph->p_vaddr;
1013         GL(dl_loaded)->l_relro_size = ph->p_memsz;
1014         break;
1015       }
1016 #ifdef USE_TLS
1017     /* Adjust the address of the TLS initialization image in case
1018        the executable is actually an ET_DYN object.  */
1019     if (GL(dl_loaded)->l_tls_initimage != NULL)
1020       GL(dl_loaded)->l_tls_initimage
1021         = (char *) GL(dl_loaded)->l_tls_initimage + GL(dl_loaded)->l_addr;
1022 #endif
1023   if (! GL(dl_loaded)->l_map_end)
1024     GL(dl_loaded)->l_map_end = ~0;
1025   if (! GL(dl_loaded)->l_text_end)
1026     GL(dl_loaded)->l_text_end = ~0;
1027   if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
1028     {
1029       /* We were invoked directly, so the program might not have a
1030          PT_INTERP.  */
1031       _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
1032       /* _dl_rtld_libname.next = NULL;  Already zero.  */
1033       GL(dl_rtld_map).l_libname =  &_dl_rtld_libname;
1034     }
1035   else
1036     assert (GL(dl_rtld_map).l_libname); /* How else did we get here?  */
1037
1038   if (! rtld_is_main)
1039     {
1040       /* Extract the contents of the dynamic section for easy access.  */
1041       elf_get_dynamic_info (GL(dl_loaded), NULL);
1042       /* Set up our cache of pointers into the hash table.  */
1043       _dl_setup_hash (GL(dl_loaded));
1044     }
1045
1046   if (__builtin_expect (mode, normal) == verify)
1047     {
1048       /* We were called just to verify that this is a dynamic
1049          executable using us as the program interpreter.  Exit with an
1050          error if we were not able to load the binary or no interpreter
1051          is specified (i.e., this is no dynamically linked binary.  */
1052       if (GL(dl_loaded)->l_ld == NULL)
1053         _exit (1);
1054
1055       /* We allow here some platform specific code.  */
1056 #ifdef DISTINGUISH_LIB_VERSIONS
1057       DISTINGUISH_LIB_VERSIONS;
1058 #endif
1059       _exit (has_interp ? 0 : 2);
1060     }
1061
1062   if (! rtld_is_main)
1063     /* Initialize the data structures for the search paths for shared
1064        objects.  */
1065     _dl_init_paths (library_path);
1066
1067   /* Put the link_map for ourselves on the chain so it can be found by
1068      name.  Note that at this point the global chain of link maps contains
1069      exactly one element, which is pointed to by dl_loaded.  */
1070   if (! GL(dl_rtld_map).l_name)
1071     /* If not invoked directly, the dynamic linker shared object file was
1072        found by the PT_INTERP name.  */
1073     GL(dl_rtld_map).l_name = (char *) GL(dl_rtld_map).l_libname->name;
1074   GL(dl_rtld_map).l_type = lt_library;
1075   GL(dl_loaded)->l_next = &GL(dl_rtld_map);
1076   GL(dl_rtld_map).l_prev = GL(dl_loaded);
1077   ++GL(dl_nloaded);
1078   ++GL(dl_load_adds);
1079
1080 #if defined(__i386__)
1081   /* Force non-TLS libraries for glibc 2.0 binaries
1082      or if a buggy binary references non-TLS errno or h_errno.  */
1083   if (__builtin_expect (GL(dl_loaded)->l_info[DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED)] == NULL, 0)
1084       && GL(dl_loaded)->l_info[DT_DEBUG])
1085     GLRO(dl_osversion) = 0x20205;
1086   else if ((__builtin_expect (mode, normal) != normal
1087             || GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_LIBLIST)] == NULL)
1088               /* Only binaries have DT_DEBUG dynamic tags...  */
1089            && GL(dl_loaded)->l_info[DT_DEBUG])
1090     {
1091       /* Workaround for buggy binaries.  This doesn't handle buggy
1092          libraries.  */
1093       bool buggy = false;
1094       const ElfW(Sym) *symtab = (const void *) D_PTR (GL(dl_loaded), l_info[DT_SYMTAB]);
1095       const char *strtab = (const void *) D_PTR (GL(dl_loaded), l_info[DT_STRTAB]);
1096       Elf_Symndx symidx;
1097       for (symidx = GL(dl_loaded)->l_buckets[0x6c994f % GL(dl_loaded)->l_nbuckets];
1098            symidx != STN_UNDEF;
1099            symidx = GL(dl_loaded)->l_chain[symidx])
1100         {
1101           if (__builtin_expect (strcmp (strtab + symtab[symidx].st_name,
1102                                         "errno") == 0, 0)
1103               && ELFW(ST_TYPE) (symtab[symidx].st_info) != STT_TLS)
1104             buggy = true;
1105         }
1106       for (symidx = GL(dl_loaded)->l_buckets[0xe5c992f % GL(dl_loaded)->l_nbuckets];
1107            symidx != STN_UNDEF;
1108            symidx = GL(dl_loaded)->l_chain[symidx])
1109         {
1110           if (__builtin_expect (strcmp (strtab + symtab[symidx].st_name,
1111                                         "h_errno") == 0, 0)
1112               && ELFW(ST_TYPE) (symtab[symidx].st_info) != STT_TLS)
1113             buggy = true;
1114         }
1115       if (__builtin_expect (buggy, false) && GLRO(dl_osversion) > 0x20401)
1116         {
1117           GLRO(dl_osversion) = 0x20401;
1118           _dl_error_printf ("Incorrectly built binary which accesses errno or h_errno directly. Needs to be fixed.\n");
1119         }
1120     }
1121 #endif
1122
1123   /* If LD_USE_LOAD_BIAS env variable has not been seen, default
1124      to not using bias for non-prelinked PIEs and libraries
1125      and using it for executables or prelinked PIEs or libraries.  */
1126   if (GLRO(dl_use_load_bias) == (ElfW(Addr)) -2)
1127     GLRO(dl_use_load_bias) = (GL(dl_loaded)->l_addr == 0) ? -1 : 0;
1128
1129   /* Set up the program header information for the dynamic linker
1130      itself.  It is needed in the dl_iterate_phdr() callbacks.  */
1131   ElfW(Ehdr) *rtld_ehdr = (ElfW(Ehdr) *) GL(dl_rtld_map).l_map_start;
1132   ElfW(Phdr) *rtld_phdr = (ElfW(Phdr) *) (GL(dl_rtld_map).l_map_start
1133                                           + rtld_ehdr->e_phoff);
1134   GL(dl_rtld_map).l_phdr = rtld_phdr;
1135   GL(dl_rtld_map).l_phnum = rtld_ehdr->e_phnum;
1136
1137   /* PT_GNU_RELRO is usually the last phdr.  */
1138   size_t cnt = rtld_ehdr->e_phnum;
1139   while (cnt-- > 0)
1140     if (rtld_phdr[cnt].p_type == PT_GNU_RELRO)
1141       {
1142         GL(dl_rtld_map).l_relro_addr = rtld_phdr[cnt].p_vaddr;
1143         GL(dl_rtld_map).l_relro_size = rtld_phdr[cnt].p_memsz;
1144         break;
1145       }
1146
1147   /* We have two ways to specify objects to preload: via environment
1148      variable and via the file /etc/ld.so.preload.  The latter can also
1149      be used when security is enabled.  */
1150   preloads = NULL;
1151   npreloads = 0;
1152
1153   if (__builtin_expect (preloadlist != NULL, 0))
1154     {
1155       /* The LD_PRELOAD environment variable gives list of libraries
1156          separated by white space or colons that are loaded before the
1157          executable's dependencies and prepended to the global scope
1158          list.  If the binary is running setuid all elements
1159          containing a '/' are ignored since it is insecure.  */
1160       char *list = strdupa (preloadlist);
1161       char *p;
1162
1163       HP_TIMING_NOW (start);
1164
1165       /* Prevent optimizing strsep.  Speed is not important here.  */
1166       while ((p = (strsep) (&list, " :")) != NULL)
1167         if (p[0] != '\0'
1168             && (__builtin_expect (! INTUSE(__libc_enable_secure), 1)
1169                 || strchr (p, '/') == NULL))
1170           {
1171             struct link_map *new_map = _dl_map_object (GL(dl_loaded), p, 1,
1172                                                        lt_library, 0, 0);
1173             if (++new_map->l_opencount == 1)
1174               /* It is no duplicate.  */
1175               ++npreloads;
1176           }
1177
1178       HP_TIMING_NOW (stop);
1179       HP_TIMING_DIFF (diff, start, stop);
1180       HP_TIMING_ACCUM_NT (load_time, diff);
1181     }
1182
1183   /* There usually is no ld.so.preload file, it should only be used
1184      for emergencies and testing.  So the open call etc should usually
1185      fail.  Using access() on a non-existing file is faster than using
1186      open().  So we do this first.  If it succeeds we do almost twice
1187      the work but this does not matter, since it is not for production
1188      use.  */
1189   static const char preload_file[] = "/etc/ld.so.preload";
1190   if (__builtin_expect (__access (preload_file, R_OK) == 0, 0))
1191     {
1192       /* Read the contents of the file.  */
1193       file = _dl_sysdep_read_whole_file (preload_file, &file_size,
1194                                          PROT_READ | PROT_WRITE);
1195       if (__builtin_expect (file != MAP_FAILED, 0))
1196         {
1197           /* Parse the file.  It contains names of libraries to be loaded,
1198              separated by white spaces or `:'.  It may also contain
1199              comments introduced by `#'.  */
1200           char *problem;
1201           char *runp;
1202           size_t rest;
1203
1204           /* Eliminate comments.  */
1205           runp = file;
1206           rest = file_size;
1207           while (rest > 0)
1208             {
1209               char *comment = memchr (runp, '#', rest);
1210               if (comment == NULL)
1211                 break;
1212
1213               rest -= comment - runp;
1214               do
1215                 *comment = ' ';
1216               while (--rest > 0 && *++comment != '\n');
1217             }
1218
1219           /* We have one problematic case: if we have a name at the end of
1220              the file without a trailing terminating characters, we cannot
1221              place the \0.  Handle the case separately.  */
1222           if (file[file_size - 1] != ' ' && file[file_size - 1] != '\t'
1223               && file[file_size - 1] != '\n' && file[file_size - 1] != ':')
1224             {
1225               problem = &file[file_size];
1226               while (problem > file && problem[-1] != ' '
1227                      && problem[-1] != '\t'
1228                      && problem[-1] != '\n' && problem[-1] != ':')
1229                 --problem;
1230
1231               if (problem > file)
1232                 problem[-1] = '\0';
1233             }
1234           else
1235             {
1236               problem = NULL;
1237               file[file_size - 1] = '\0';
1238             }
1239
1240           HP_TIMING_NOW (start);
1241
1242           if (file != problem)
1243             {
1244               char *p;
1245               runp = file;
1246               while ((p = strsep (&runp, ": \t\n")) != NULL)
1247                 if (p[0] != '\0')
1248                   {
1249                     const char *objname;
1250                     const char *err_str = NULL;
1251                     struct map_args args;
1252
1253                     args.str = p;
1254                     args.loader = GL(dl_loaded);
1255                     args.is_preloaded = 1;
1256                     args.mode = 0;
1257
1258                     (void) _dl_catch_error (&objname, &err_str, map_doit,
1259                                             &args);
1260                     if (__builtin_expect (err_str != NULL, 0))
1261                       {
1262                         _dl_error_printf ("\
1263 ERROR: ld.so: object '%s' from %s cannot be preloaded: ignored.\n",
1264                                           p, preload_file);
1265                         /* No need to call free, this is still before
1266                            the libc's malloc is used.  */
1267                       }
1268                     else if (++args.map->l_opencount == 1)
1269                       /* It is no duplicate.  */
1270                       ++npreloads;
1271                   }
1272             }
1273
1274           if (problem != NULL)
1275             {
1276               char *p = strndupa (problem, file_size - (problem - file));
1277               struct link_map *new_map = _dl_map_object (GL(dl_loaded), p, 1,
1278                                                          lt_library, 0, 0);
1279               if (++new_map->l_opencount == 1)
1280                 /* It is no duplicate.  */
1281                 ++npreloads;
1282             }
1283
1284           HP_TIMING_NOW (stop);
1285           HP_TIMING_DIFF (diff, start, stop);
1286           HP_TIMING_ACCUM_NT (load_time, diff);
1287
1288           /* We don't need the file anymore.  */
1289           __munmap (file, file_size);
1290         }
1291     }
1292
1293
1294 #if defined(__i386__) || defined(__alpha__) || (defined(__sparc__) && !defined(__arch64__))
1295   /*
1296    * Modifications by Red Hat Software
1297    *
1298    * Deal with the broken binaries from the non-versioned ages of glibc.
1299    * If a binary does not have version information enabled, we assume that
1300    * it is a glibc 2.0 binary and we load a compatibility library to try to
1301    * overcome binary incompatibilities.
1302    *                    Blame: gafton@redhat.com
1303    */
1304 #define LIB_NOVERSION "/lib/libNoVersion.so.1"
1305
1306   if (__builtin_expect (GL(dl_loaded)->l_info[DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED)] == NULL, 0)
1307       && (GL(dl_loaded)->l_info[DT_DEBUG] || !(GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)))
1308     {
1309       struct stat test_st;
1310       int test_fd;
1311       int can_load;
1312       
1313       HP_TIMING_NOW (start);
1314            
1315 /*       _dl_sysdep_message("Loading compatibility library... ", NULL); */
1316
1317       can_load = 1;
1318       test_fd = __open (LIB_NOVERSION, O_RDONLY);
1319       if (test_fd < 0) {
1320           can_load = 0;
1321 /*        _dl_sysdep_message(" Can't find " LIB_NOVERSION "\n",  NULL); */
1322       } else {
1323           if (__fxstat (_STAT_VER, test_fd, &test_st) < 0 || test_st.st_size == 0) {
1324               can_load = 0;
1325 /*            _dl_sysdep_message(" Can't stat " LIB_NOVERSION "\n",  NULL); */
1326           }
1327       }
1328       
1329       if (test_fd >= 0) /* open did no fail.. */
1330           __close(test_fd); /* avoid fd leaks */
1331
1332       if (can_load != 0) {
1333           struct link_map *new_map;
1334           new_map = _dl_map_object (GL(dl_loaded), LIB_NOVERSION,
1335                                     1, lt_library, 0, 0);
1336           if (++new_map->l_opencount == 1) {
1337               /* It is no duplicate.  */
1338               ++npreloads;
1339 /*            _dl_sysdep_message(" DONE\n", NULL); */
1340           } else {
1341 /*            _dl_sysdep_message(" FAILED\n", NULL); */
1342           }
1343       }
1344           
1345       HP_TIMING_NOW (stop);
1346       HP_TIMING_DIFF (diff, start, stop);
1347       HP_TIMING_ACCUM_NT (load_time, diff);
1348     }
1349 #endif
1350
1351   if (__builtin_expect (npreloads, 0) != 0)
1352     {
1353       /* Set up PRELOADS with a vector of the preloaded libraries.  */
1354       struct link_map *l;
1355       preloads = __alloca (npreloads * sizeof preloads[0]);
1356       l = GL(dl_rtld_map).l_next; /* End of the chain before preloads.  */
1357       i = 0;
1358       do
1359         {
1360           preloads[i++] = l;
1361           l = l->l_next;
1362         } while (l);
1363       assert (i == npreloads);
1364     }
1365
1366 #ifdef NEED_DL_SYSINFO
1367   struct link_map *sysinfo_map = NULL;
1368   if (GLRO(dl_sysinfo_dso) != NULL)
1369     {
1370       /* Do an abridged version of the work _dl_map_object_from_fd would do
1371          to map in the object.  It's already mapped and prelinked (and
1372          better be, since it's read-only and so we couldn't relocate it).
1373          We just want our data structures to describe it as if we had just
1374          mapped and relocated it normally.  */
1375       struct link_map *l = _dl_new_object ((char *) "", "", lt_library, NULL,
1376                                            0);
1377       if (__builtin_expect (l != NULL, 1))
1378         {
1379           static ElfW(Dyn) dyn_temp[DL_RO_DYN_TEMP_CNT] attribute_relro;
1380
1381           l->l_phdr = ((const void *) GLRO(dl_sysinfo_dso)
1382                        + GLRO(dl_sysinfo_dso)->e_phoff);
1383           l->l_phnum = GLRO(dl_sysinfo_dso)->e_phnum;
1384           for (uint_fast16_t i = 0; i < l->l_phnum; ++i)
1385             {
1386               const ElfW(Phdr) *const ph = &l->l_phdr[i];
1387               if (ph->p_type == PT_DYNAMIC)
1388                 {
1389                   l->l_ld = (void *) ph->p_vaddr;
1390                   l->l_ldnum = ph->p_memsz / sizeof (ElfW(Dyn));
1391                 }
1392               else if (ph->p_type == PT_LOAD)
1393                 {
1394                   if (! l->l_addr)
1395                     l->l_addr = ph->p_vaddr;
1396                   else if (ph->p_vaddr + ph->p_memsz >= l->l_map_end)
1397                     l->l_map_end = ph->p_vaddr + ph->p_memsz;
1398                   else if ((ph->p_flags & PF_X)
1399                            && ph->p_vaddr + ph->p_memsz >= l->l_text_end)
1400                     l->l_text_end = ph->p_vaddr + ph->p_memsz;
1401                 }
1402             }
1403           l->l_map_start = (ElfW(Addr)) GLRO(dl_sysinfo_dso);
1404           l->l_addr = l->l_map_start - l->l_addr;
1405           l->l_map_end += l->l_addr;
1406           l->l_text_end += l->l_addr;
1407           l->l_ld = (void *) ((ElfW(Addr)) l->l_ld + l->l_addr);
1408           elf_get_dynamic_info (l, dyn_temp);
1409           _dl_setup_hash (l);
1410           l->l_relocated = 1;
1411
1412           /* Now that we have the info handy, use the DSO image's soname
1413              so this object can be looked up by name.  Note that we do not
1414              set l_name here.  That field gives the file name of the DSO,
1415              and this DSO is not associated with any file.  */
1416           if (l->l_info[DT_SONAME] != NULL)
1417             {
1418               /* Work around a kernel problem.  The kernel cannot handle
1419                  addresses in the vsyscall DSO pages in writev() calls.  */
1420               const char *dsoname = ((char *) D_PTR (l, l_info[DT_STRTAB])
1421                                      + l->l_info[DT_SONAME]->d_un.d_val);
1422               size_t len = strlen (dsoname);
1423               char *copy = malloc (len);
1424               if (copy == NULL)
1425                 _dl_fatal_printf ("out of memory\n");
1426               l->l_libname->name = memcpy (copy, dsoname, len);
1427             }
1428
1429           /* We have a prelinked DSO preloaded by the system.  */
1430           if (GLRO(dl_sysinfo) == DL_SYSINFO_DEFAULT)
1431             GLRO(dl_sysinfo) = GLRO(dl_sysinfo_dso)->e_entry + l->l_addr;
1432           sysinfo_map = l;
1433         }
1434     }
1435 #endif
1436
1437   /* Load all the libraries specified by DT_NEEDED entries.  If LD_PRELOAD
1438      specified some libraries to load, these are inserted before the actual
1439      dependencies in the executable's searchlist for symbol resolution.  */
1440   HP_TIMING_NOW (start);
1441   _dl_map_object_deps (GL(dl_loaded), preloads, npreloads, mode == trace, 0);
1442   HP_TIMING_NOW (stop);
1443   HP_TIMING_DIFF (diff, start, stop);
1444   HP_TIMING_ACCUM_NT (load_time, diff);
1445
1446   /* Mark all objects as being in the global scope and set the open
1447      counter.  */
1448   for (i = GL(dl_loaded)->l_searchlist.r_nlist; i > 0; )
1449     {
1450       --i;
1451       GL(dl_loaded)->l_searchlist.r_list[i]->l_global = 1;
1452       ++GL(dl_loaded)->l_searchlist.r_list[i]->l_opencount;
1453     }
1454
1455 #ifndef MAP_ANON
1456   /* We are done mapping things, so close the zero-fill descriptor.  */
1457   __close (_dl_zerofd);
1458   _dl_zerofd = -1;
1459 #endif
1460
1461   /* Remove _dl_rtld_map from the chain.  */
1462   GL(dl_rtld_map).l_prev->l_next = GL(dl_rtld_map).l_next;
1463   if (GL(dl_rtld_map).l_next)
1464     GL(dl_rtld_map).l_next->l_prev = GL(dl_rtld_map).l_prev;
1465
1466   if (__builtin_expect (GL(dl_rtld_map).l_opencount > 1, 1))
1467     {
1468       /* Some DT_NEEDED entry referred to the interpreter object itself, so
1469          put it back in the list of visible objects.  We insert it into the
1470          chain in symbol search order because gdb uses the chain's order as
1471          its symbol search order.  */
1472       i = 1;
1473       while (GL(dl_loaded)->l_searchlist.r_list[i] != &GL(dl_rtld_map))
1474         ++i;
1475       GL(dl_rtld_map).l_prev = GL(dl_loaded)->l_searchlist.r_list[i - 1];
1476       if (__builtin_expect (mode, normal) == normal)
1477         {
1478           GL(dl_rtld_map).l_next = (i + 1 < GL(dl_loaded)->l_searchlist.r_nlist
1479                                     ? GL(dl_loaded)->l_searchlist.r_list[i + 1]
1480                                     : NULL);
1481 #ifdef NEED_DL_SYSINFO
1482           if (sysinfo_map != NULL
1483               && GL(dl_rtld_map).l_prev->l_next == sysinfo_map
1484               && GL(dl_rtld_map).l_next != sysinfo_map)
1485             GL(dl_rtld_map).l_prev = sysinfo_map;
1486 #endif
1487         }
1488       else
1489         /* In trace mode there might be an invisible object (which we
1490            could not find) after the previous one in the search list.
1491            In this case it doesn't matter much where we put the
1492            interpreter object, so we just initialize the list pointer so
1493            that the assertion below holds.  */
1494         GL(dl_rtld_map).l_next = GL(dl_rtld_map).l_prev->l_next;
1495
1496       assert (GL(dl_rtld_map).l_prev->l_next == GL(dl_rtld_map).l_next);
1497       GL(dl_rtld_map).l_prev->l_next = &GL(dl_rtld_map);
1498       if (GL(dl_rtld_map).l_next != NULL)
1499         {
1500           assert (GL(dl_rtld_map).l_next->l_prev == GL(dl_rtld_map).l_prev);
1501           GL(dl_rtld_map).l_next->l_prev = &GL(dl_rtld_map);
1502         }
1503     }
1504
1505   /* Now let us see whether all libraries are available in the
1506      versions we need.  */
1507   {
1508     struct version_check_args args;
1509     args.doexit = mode == normal;
1510     args.dotrace = mode == trace;
1511     _dl_receive_error (print_missing_version, version_check_doit, &args);
1512   }
1513
1514 #ifdef USE_TLS
1515   /* Now it is time to determine the layout of the static TLS block
1516      and allocate it for the initial thread.  Note that we always
1517      allocate the static block, we never defer it even if no
1518      DF_STATIC_TLS bit is set.  The reason is that we know glibc will
1519      use the static model.  First add the dynamic linker to the list
1520      if it also uses TLS.  */
1521   if (GL(dl_rtld_map).l_tls_blocksize != 0)
1522     /* Assign a module ID.  */
1523     GL(dl_rtld_map).l_tls_modid = _dl_next_tls_modid ();
1524
1525 # ifndef TLS_INIT_TP_EXPENSIVE
1526 #  define TLS_INIT_TP_EXPENSIVE 0
1527 # endif
1528
1529   /* We do not initialize any of the TLS functionality unless any of the
1530      initial modules uses TLS.  This makes dynamic loading of modules with
1531      TLS impossible, but to support it requires either eagerly doing setup
1532      now or lazily doing it later.  Doing it now makes us incompatible with
1533      an old kernel that can't perform TLS_INIT_TP, even if no TLS is ever
1534      used.  Trying to do it lazily is too hairy to try when there could be
1535      multiple threads (from a non-TLS-using libpthread).  */
1536   if (!TLS_INIT_TP_EXPENSIVE || GL(dl_tls_max_dtv_idx) > 0)
1537     {
1538       struct link_map *l;
1539       size_t nelem;
1540       struct dtv_slotinfo *slotinfo;
1541
1542       /* Number of elements in the static TLS block.  */
1543       GL(dl_tls_static_nelem) = GL(dl_tls_max_dtv_idx);
1544
1545       /* Allocate the array which contains the information about the
1546          dtv slots.  We allocate a few entries more than needed to
1547          avoid the need for reallocation.  */
1548       nelem = GL(dl_tls_max_dtv_idx) + 1 + TLS_SLOTINFO_SURPLUS;
1549
1550       /* Allocate.  */
1551       GL(dl_tls_dtv_slotinfo_list) = (struct dtv_slotinfo_list *)
1552         malloc (sizeof (struct dtv_slotinfo_list)
1553                 + nelem * sizeof (struct dtv_slotinfo));
1554       /* No need to check the return value.  If memory allocation failed
1555          the program would have been terminated.  */
1556
1557       slotinfo = memset (GL(dl_tls_dtv_slotinfo_list)->slotinfo, '\0',
1558                          nelem * sizeof (struct dtv_slotinfo));
1559       GL(dl_tls_dtv_slotinfo_list)->len = nelem;
1560       GL(dl_tls_dtv_slotinfo_list)->next = NULL;
1561
1562       /* Fill in the information from the loaded modules.  */
1563       for (l = GL(dl_loaded), i = 0; l != NULL; l = l->l_next)
1564         if (l->l_tls_blocksize != 0)
1565           /* This is a module with TLS data.  Store the map reference.
1566              The generation counter is zero.  */
1567           slotinfo[++i].map = l;
1568       assert (i == GL(dl_tls_max_dtv_idx));
1569
1570       /* Compute the TLS offsets for the various blocks.  */
1571       _dl_determine_tlsoffset ();
1572
1573       /* Construct the static TLS block and the dtv for the initial
1574          thread.  For some platforms this will include allocating memory
1575          for the thread descriptor.  The memory for the TLS block will
1576          never be freed.  It should be allocated accordingly.  The dtv
1577          array can be changed if dynamic loading requires it.  */
1578       tcbp = _dl_allocate_tls_storage ();
1579       if (tcbp == NULL)
1580         _dl_fatal_printf ("\
1581 cannot allocate TLS data structures for initial thread");
1582
1583       /* Store for detection of the special case by __tls_get_addr
1584          so it knows not to pass this dtv to the normal realloc.  */
1585       GL(dl_initial_dtv) = GET_DTV (tcbp);
1586     }
1587 #endif
1588
1589   if (__builtin_expect (mode, normal) != normal)
1590     {
1591       /* We were run just to list the shared libraries.  It is
1592          important that we do this before real relocation, because the
1593          functions we call below for output may no longer work properly
1594          after relocation.  */
1595       struct link_map *l;
1596
1597       if (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1598         {
1599           struct r_scope_elem *scope = &GL(dl_loaded)->l_searchlist;
1600
1601           for (i = 0; i < scope->r_nlist; i++)
1602             {
1603               l = scope->r_list [i];
1604               if (l->l_faked)
1605                 {
1606                   _dl_printf ("\t%s => not found\n", l->l_libname->name);
1607                   continue;
1608                 }
1609               if (_dl_name_match_p (GLRO(dl_trace_prelink), l))
1610                 GLRO(dl_trace_prelink_map) = l;
1611               _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)",
1612                           l->l_libname->name[0] ? l->l_libname->name
1613                           : rtld_progname ?: "<main program>",
1614                           l->l_name[0] ? l->l_name
1615                           : rtld_progname ?: "<main program>",
1616                           (int) sizeof l->l_map_start * 2,
1617                           (size_t) l->l_map_start,
1618                           (int) sizeof l->l_addr * 2,
1619                           (size_t) l->l_addr);
1620 #ifdef USE_TLS
1621               if (l->l_tls_modid)
1622                 _dl_printf (" TLS(0x%Zx, 0x%0*Zx)\n", l->l_tls_modid,
1623                             (int) sizeof l->l_tls_offset * 2,
1624                             (size_t) l->l_tls_offset);
1625               else
1626 #endif
1627                 _dl_printf ("\n");
1628             }
1629         }
1630       else if (GLRO(dl_debug_mask) & DL_DEBUG_UNUSED)
1631         {
1632           /* Look through the dependencies of the main executable
1633              and determine which of them is not actually
1634              required.  */
1635           struct link_map *l = GL(dl_loaded);
1636
1637           /* Relocate the main executable.  */
1638           struct relocate_args args = { .l = l, .lazy = GLRO(dl_lazy) };
1639           _dl_receive_error (print_unresolved, relocate_doit, &args);
1640
1641           /* This loop depends on the dependencies of the executable to
1642              correspond in number and order to the DT_NEEDED entries.  */
1643           ElfW(Dyn) *dyn = GL(dl_loaded)->l_ld;
1644           bool first = true;
1645           while (dyn->d_tag != DT_NULL)
1646             {
1647               if (dyn->d_tag == DT_NEEDED)
1648                 {
1649                   l = l->l_next;
1650
1651                   if (!l->l_used)
1652                     {
1653                       if (first)
1654                         {
1655                           _dl_printf ("Unused direct dependencies:\n");
1656                           first = false;
1657                         }
1658
1659                       _dl_printf ("\t%s\n", l->l_name);
1660                     }
1661                 }
1662
1663               ++dyn;
1664             }
1665
1666           _exit (first != true);
1667         }
1668       else if (! GL(dl_loaded)->l_info[DT_NEEDED])
1669         _dl_printf ("\tstatically linked\n");
1670       else
1671         {
1672           for (l = GL(dl_loaded)->l_next; l; l = l->l_next)
1673             if (l->l_faked)
1674               /* The library was not found.  */
1675               _dl_printf ("\t%s => not found\n", l->l_libname->name);
1676             else if (strcmp (l->l_libname->name, l->l_name) == 0)
1677               _dl_printf ("\t%s (0x%0*Zx)\n", l->l_libname->name,
1678                           (int) sizeof l->l_map_start * 2,
1679                           (size_t) l->l_map_start);
1680             else
1681               _dl_printf ("\t%s => %s (0x%0*Zx)\n", l->l_libname->name,
1682                           l->l_name, (int) sizeof l->l_map_start * 2,
1683                           (size_t) l->l_map_start);
1684         }
1685
1686       if (__builtin_expect (mode, trace) != trace)
1687         for (i = 1; i < (unsigned int) _dl_argc; ++i)
1688           {
1689             const ElfW(Sym) *ref = NULL;
1690             ElfW(Addr) loadbase;
1691             lookup_t result;
1692
1693             result = _dl_lookup_symbol_x (INTUSE(_dl_argv)[i], GL(dl_loaded),
1694                                           &ref, GL(dl_loaded)->l_scope, NULL,
1695                                           ELF_RTYPE_CLASS_PLT,
1696                                           DL_LOOKUP_ADD_DEPENDENCY, NULL);
1697
1698             loadbase = LOOKUP_VALUE_ADDRESS (result);
1699
1700             _dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
1701                         INTUSE(_dl_argv)[i],
1702                         (int) sizeof ref->st_value * 2,
1703                         (size_t) ref->st_value,
1704                         (int) sizeof loadbase * 2, (size_t) loadbase);
1705           }
1706       else
1707         {
1708           /* If LD_WARN is set warn about undefined symbols.  */
1709           if (GLRO(dl_lazy) >= 0 && GLRO(dl_verbose))
1710             {
1711               /* We have to do symbol dependency testing.  */
1712               struct relocate_args args;
1713               struct link_map *l;
1714
1715               args.lazy = GLRO(dl_lazy);
1716
1717               l = GL(dl_loaded);
1718               while (l->l_next)
1719                 l = l->l_next;
1720               do
1721                 {
1722                   if (l != &GL(dl_rtld_map) && ! l->l_faked)
1723                     {
1724                       args.l = l;
1725                       _dl_receive_error (print_unresolved, relocate_doit,
1726                                          &args);
1727                     }
1728                   l = l->l_prev;
1729                 } while (l);
1730
1731               if ((GLRO(dl_debug_mask) & DL_DEBUG_PRELINK)
1732                   && GL(dl_rtld_map).l_opencount > 1)
1733                 _dl_relocate_object (&GL(dl_rtld_map), GL(dl_loaded)->l_scope,
1734                                      0, 0);
1735             }
1736
1737 #define VERNEEDTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (DT_VERNEED))
1738           if (version_info)
1739             {
1740               /* Print more information.  This means here, print information
1741                  about the versions needed.  */
1742               int first = 1;
1743               struct link_map *map = GL(dl_loaded);
1744
1745               for (map = GL(dl_loaded); map != NULL; map = map->l_next)
1746                 {
1747                   const char *strtab;
1748                   ElfW(Dyn) *dyn = map->l_info[VERNEEDTAG];
1749                   ElfW(Verneed) *ent;
1750
1751                   if (dyn == NULL)
1752                     continue;
1753
1754                   strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
1755                   ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
1756
1757                   if (first)
1758                     {
1759                       _dl_printf ("\n\tVersion information:\n");
1760                       first = 0;
1761                     }
1762
1763                   _dl_printf ("\t%s:\n",
1764                               map->l_name[0] ? map->l_name : rtld_progname);
1765
1766                   while (1)
1767                     {
1768                       ElfW(Vernaux) *aux;
1769                       struct link_map *needed;
1770
1771                       needed = find_needed (strtab + ent->vn_file);
1772                       aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
1773
1774                       while (1)
1775                         {
1776                           const char *fname = NULL;
1777
1778                           if (needed != NULL
1779                               && match_version (strtab + aux->vna_name,
1780                                                 needed))
1781                             fname = needed->l_name;
1782
1783                           _dl_printf ("\t\t%s (%s) %s=> %s\n",
1784                                       strtab + ent->vn_file,
1785                                       strtab + aux->vna_name,
1786                                       aux->vna_flags & VER_FLG_WEAK
1787                                       ? "[WEAK] " : "",
1788                                       fname ?: "not found");
1789
1790                           if (aux->vna_next == 0)
1791                             /* No more symbols.  */
1792                             break;
1793
1794                           /* Next symbol.  */
1795                           aux = (ElfW(Vernaux) *) ((char *) aux
1796                                                    + aux->vna_next);
1797                         }
1798
1799                       if (ent->vn_next == 0)
1800                         /* No more dependencies.  */
1801                         break;
1802
1803                       /* Next dependency.  */
1804                       ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
1805                     }
1806                 }
1807             }
1808         }
1809
1810       _exit (0);
1811     }
1812
1813   if (GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_LIBLIST)]
1814       && ! __builtin_expect (GLRO(dl_profile) != NULL, 0))
1815     {
1816       ElfW(Lib) *liblist, *liblistend;
1817       struct link_map **r_list, **r_listend, *l;
1818       const char *strtab = (const void *) D_PTR (GL(dl_loaded),
1819                                                  l_info[DT_STRTAB]);
1820
1821       assert (GL(dl_loaded)->l_info [VALIDX (DT_GNU_LIBLISTSZ)] != NULL);
1822       liblist = (ElfW(Lib) *)
1823                 GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_LIBLIST)]->d_un.d_ptr;
1824       liblistend = (ElfW(Lib) *)
1825                    ((char *) liblist
1826                     + GL(dl_loaded)->l_info [VALIDX (DT_GNU_LIBLISTSZ)]->d_un.d_val);
1827       r_list = GL(dl_loaded)->l_searchlist.r_list;
1828       r_listend = r_list + GL(dl_loaded)->l_searchlist.r_nlist;
1829
1830       for (; r_list < r_listend && liblist < liblistend; r_list++)
1831         {
1832           l = *r_list;
1833
1834           if (l == GL(dl_loaded))
1835             continue;
1836
1837           /* If the library is not mapped where it should, fail.  */
1838           if (l->l_addr)
1839             break;
1840
1841           /* Next, check if checksum matches.  */
1842           if (l->l_info [VALIDX(DT_CHECKSUM)] == NULL
1843               || l->l_info [VALIDX(DT_CHECKSUM)]->d_un.d_val
1844                  != liblist->l_checksum)
1845             break;
1846
1847           if (l->l_info [VALIDX(DT_GNU_PRELINKED)] == NULL
1848               || l->l_info [VALIDX(DT_GNU_PRELINKED)]->d_un.d_val
1849                  != liblist->l_time_stamp)
1850             break;
1851
1852           if (! _dl_name_match_p (strtab + liblist->l_name, l))
1853             break;
1854
1855           ++liblist;
1856         }
1857
1858
1859       if (r_list == r_listend && liblist == liblistend)
1860         prelinked = true;
1861
1862       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
1863         _dl_debug_printf ("\nprelink checking: %s\n",
1864                           prelinked ? "ok" : "failed");
1865     }
1866
1867
1868   /* Initialize _r_debug.  */
1869   struct r_debug *r = _dl_debug_initialize (GL(dl_rtld_map).l_addr);
1870   {
1871     struct link_map *l;
1872
1873     l = GL(dl_loaded);
1874
1875 #ifdef ELF_MACHINE_DEBUG_SETUP
1876
1877     /* Some machines (e.g. MIPS) don't use DT_DEBUG in this way.  */
1878
1879     ELF_MACHINE_DEBUG_SETUP (l, r);
1880     ELF_MACHINE_DEBUG_SETUP (&GL(dl_rtld_map), r);
1881
1882 #else
1883
1884     if (l->l_info[DT_DEBUG] != NULL)
1885       /* There is a DT_DEBUG entry in the dynamic section.  Fill it in
1886          with the run-time address of the r_debug structure  */
1887       l->l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1888
1889     /* Fill in the pointer in the dynamic linker's own dynamic section, in
1890        case you run gdb on the dynamic linker directly.  */
1891     if (GL(dl_rtld_map).l_info[DT_DEBUG] != NULL)
1892       GL(dl_rtld_map).l_info[DT_DEBUG]->d_un.d_ptr = (ElfW(Addr)) r;
1893 #endif
1894   }
1895
1896   /* Now set up the variable which helps the assembler startup code.  */
1897   GL(dl_main_searchlist) = &GL(dl_loaded)->l_searchlist;
1898   GL(dl_global_scope)[0] = &GL(dl_loaded)->l_searchlist;
1899
1900   /* Save the information about the original global scope list since
1901      we need it in the memory handling later.  */
1902   GLRO(dl_initial_searchlist) = *GL(dl_main_searchlist);
1903
1904   if (prelinked)
1905     {
1906       struct link_map *l;
1907
1908       if (GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_CONFLICT)] != NULL)
1909         {
1910           ElfW(Rela) *conflict, *conflictend;
1911 #ifndef HP_TIMING_NONAVAIL
1912           hp_timing_t start;
1913           hp_timing_t stop;
1914 #endif
1915
1916           HP_TIMING_NOW (start);
1917           assert (GL(dl_loaded)->l_info [VALIDX (DT_GNU_CONFLICTSZ)] != NULL);
1918           conflict = (ElfW(Rela) *)
1919             GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_CONFLICT)]->d_un.d_ptr;
1920           conflictend = (ElfW(Rela) *)
1921             ((char *) conflict
1922              + GL(dl_loaded)->l_info [VALIDX (DT_GNU_CONFLICTSZ)]->d_un.d_val);
1923           _dl_resolve_conflicts (GL(dl_loaded), conflict, conflictend);
1924           HP_TIMING_NOW (stop);
1925           HP_TIMING_DIFF (relocate_time, start, stop);
1926         }
1927
1928
1929       /* Mark all the objects so we know they have been already relocated.  */
1930       for (l = GL(dl_loaded); l != NULL; l = l->l_next)
1931         {
1932           l->l_relocated = 1;
1933           if (l->l_relro_size)
1934             _dl_protect_relro (l);
1935         }
1936
1937       _dl_sysdep_start_cleanup ();
1938     }
1939   else
1940     {
1941       /* Now we have all the objects loaded.  Relocate them all except for
1942          the dynamic linker itself.  We do this in reverse order so that copy
1943          relocs of earlier objects overwrite the data written by later
1944          objects.  We do not re-relocate the dynamic linker itself in this
1945          loop because that could result in the GOT entries for functions we
1946          call being changed, and that would break us.  It is safe to relocate
1947          the dynamic linker out of order because it has no copy relocs (we
1948          know that because it is self-contained).  */
1949
1950       struct link_map *l;
1951       int consider_profiling = GLRO(dl_profile) != NULL;
1952 #ifndef HP_TIMING_NONAVAIL
1953       hp_timing_t start;
1954       hp_timing_t stop;
1955       hp_timing_t add;
1956 #endif
1957
1958       /* If we are profiling we also must do lazy reloaction.  */
1959       GLRO(dl_lazy) |= consider_profiling;
1960
1961       l = GL(dl_loaded);
1962       while (l->l_next)
1963         l = l->l_next;
1964
1965       HP_TIMING_NOW (start);
1966       do
1967         {
1968           /* While we are at it, help the memory handling a bit.  We have to
1969              mark some data structures as allocated with the fake malloc()
1970              implementation in ld.so.  */
1971           struct libname_list *lnp = l->l_libname->next;
1972
1973           while (__builtin_expect (lnp != NULL, 0))
1974             {
1975               lnp->dont_free = 1;
1976               lnp = lnp->next;
1977             }
1978
1979           if (l != &GL(dl_rtld_map))
1980             _dl_relocate_object (l, l->l_scope, GLRO(dl_lazy),
1981                                  consider_profiling);
1982
1983           l = l->l_prev;
1984         }
1985       while (l);
1986       HP_TIMING_NOW (stop);
1987
1988       HP_TIMING_DIFF (relocate_time, start, stop);
1989
1990       /* Do any necessary cleanups for the startup OS interface code.
1991          We do these now so that no calls are made after rtld re-relocation
1992          which might be resolved to different functions than we expect.
1993          We cannot do this before relocating the other objects because
1994          _dl_relocate_object might need to call `mprotect' for DT_TEXTREL.  */
1995       _dl_sysdep_start_cleanup ();
1996
1997       /* Now enable profiling if needed.  Like the previous call,
1998          this has to go here because the calls it makes should use the
1999          rtld versions of the functions (particularly calloc()), but it
2000          needs to have _dl_profile_map set up by the relocator.  */
2001       if (__builtin_expect (GL(dl_profile_map) != NULL, 0))
2002         /* We must prepare the profiling.  */
2003         _dl_start_profile ();
2004
2005       if (GL(dl_rtld_map).l_opencount > 1)
2006         {
2007           /* There was an explicit ref to the dynamic linker as a shared lib.
2008              Re-relocate ourselves with user-controlled symbol definitions.  */
2009           HP_TIMING_NOW (start);
2010           _dl_relocate_object (&GL(dl_rtld_map), GL(dl_loaded)->l_scope, 0, 0);
2011           HP_TIMING_NOW (stop);
2012           HP_TIMING_DIFF (add, start, stop);
2013           HP_TIMING_ACCUM_NT (relocate_time, add);
2014         }
2015     }
2016
2017 #ifndef NONTLS_INIT_TP
2018 # define NONTLS_INIT_TP do { } while (0)
2019 #endif
2020
2021 #ifdef USE_TLS
2022   if (GL(dl_tls_max_dtv_idx) > 0 || USE___THREAD || !TLS_INIT_TP_EXPENSIVE)
2023     {
2024       /* Now that we have completed relocation, the initializer data
2025          for the TLS blocks has its final values and we can copy them
2026          into the main thread's TLS area, which we allocated above.  */
2027       _dl_allocate_tls_init (tcbp);
2028
2029       /* And finally install it for the main thread.  If ld.so itself uses
2030          TLS we know the thread pointer was initialized earlier.  */
2031       const char *lossage = TLS_INIT_TP (tcbp, USE___THREAD);
2032       if (__builtin_expect (lossage != NULL, 0))
2033         _dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage);
2034     }
2035   else
2036 #endif
2037     NONTLS_INIT_TP;
2038
2039   /* Notify the debugger that all objects are now mapped in.  */
2040   r->r_state = RT_ADD;
2041   _dl_debug_state ();
2042
2043 #ifndef MAP_COPY
2044   /* We must munmap() the cache file.  */
2045   _dl_unload_cache ();
2046 #endif
2047
2048   /* Once we return, _dl_sysdep_start will invoke
2049      the DT_INIT functions and then *USER_ENTRY.  */
2050 }
2051 \f
2052 /* This is a little helper function for resolving symbols while
2053    tracing the binary.  */
2054 static void
2055 print_unresolved (int errcode __attribute__ ((unused)), const char *objname,
2056                   const char *errstring)
2057 {
2058   if (objname[0] == '\0')
2059     objname = rtld_progname ?: "<main program>";
2060   _dl_error_printf ("%s (%s)\n", errstring, objname);
2061 }
2062 \f
2063 /* This is a little helper function for resolving symbols while
2064    tracing the binary.  */
2065 static void
2066 print_missing_version (int errcode __attribute__ ((unused)),
2067                        const char *objname, const char *errstring)
2068 {
2069   _dl_error_printf ("%s: %s: %s\n", rtld_progname ?: "<program name unknown>",
2070                     objname, errstring);
2071 }
2072 \f
2073 /* Nonzero if any of the debugging options is enabled.  */
2074 static int any_debug attribute_relro;
2075
2076 /* Process the string given as the parameter which explains which debugging
2077    options are enabled.  */
2078 static void
2079 process_dl_debug (const char *dl_debug)
2080 {
2081   /* When adding new entries make sure that the maximal length of a name
2082      is correctly handled in the LD_DEBUG_HELP code below.  */
2083   static const struct
2084   {
2085     unsigned char len;
2086     const char name[10];
2087     const char helptext[41];
2088     unsigned short int mask;
2089   } debopts[] =
2090     {
2091 #define LEN_AND_STR(str) sizeof (str) - 1, str
2092       { LEN_AND_STR ("libs"), "display library search paths",
2093         DL_DEBUG_LIBS | DL_DEBUG_IMPCALLS },
2094       { LEN_AND_STR ("reloc"), "display relocation processing",
2095         DL_DEBUG_RELOC | DL_DEBUG_IMPCALLS },
2096       { LEN_AND_STR ("files"), "display progress for input file",
2097         DL_DEBUG_FILES | DL_DEBUG_IMPCALLS },
2098       { LEN_AND_STR ("symbols"), "display symbol table processing",
2099         DL_DEBUG_SYMBOLS | DL_DEBUG_IMPCALLS },
2100       { LEN_AND_STR ("bindings"), "display information about symbol binding",
2101         DL_DEBUG_BINDINGS | DL_DEBUG_IMPCALLS },
2102       { LEN_AND_STR ("versions"), "display version dependencies",
2103         DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
2104       { LEN_AND_STR ("all"), "all previous options combined",
2105         DL_DEBUG_LIBS | DL_DEBUG_RELOC | DL_DEBUG_FILES | DL_DEBUG_SYMBOLS
2106         | DL_DEBUG_BINDINGS | DL_DEBUG_VERSIONS | DL_DEBUG_IMPCALLS },
2107       { LEN_AND_STR ("statistics"), "display relocation statistics",
2108         DL_DEBUG_STATISTICS },
2109       { LEN_AND_STR ("unused"), "determined unused DSOs",
2110         DL_DEBUG_UNUSED },
2111       { LEN_AND_STR ("help"), "display this help message and exit",
2112         DL_DEBUG_HELP },
2113     };
2114 #define ndebopts (sizeof (debopts) / sizeof (debopts[0]))
2115
2116   /* Skip separating white spaces and commas.  */
2117   while (*dl_debug != '\0')
2118     {
2119       if (*dl_debug != ' ' && *dl_debug != ',' && *dl_debug != ':')
2120         {
2121           size_t cnt;
2122           size_t len = 1;
2123
2124           while (dl_debug[len] != '\0' && dl_debug[len] != ' '
2125                  && dl_debug[len] != ',' && dl_debug[len] != ':')
2126             ++len;
2127
2128           for (cnt = 0; cnt < ndebopts; ++cnt)
2129             if (debopts[cnt].len == len
2130                 && memcmp (dl_debug, debopts[cnt].name, len) == 0)
2131               {
2132                 GLRO(dl_debug_mask) |= debopts[cnt].mask;
2133                 any_debug = 1;
2134                 break;
2135               }
2136
2137           if (cnt == ndebopts)
2138             {
2139               /* Display a warning and skip everything until next
2140                  separator.  */
2141               char *copy = strndupa (dl_debug, len);
2142               _dl_error_printf ("\
2143 warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy);
2144             }
2145
2146           dl_debug += len;
2147           continue;
2148         }
2149
2150       ++dl_debug;
2151     }
2152
2153   if (GLRO(dl_debug_mask) & DL_DEBUG_HELP)
2154     {
2155       size_t cnt;
2156
2157       _dl_printf ("\
2158 Valid options for the LD_DEBUG environment variable are:\n\n");
2159
2160       for (cnt = 0; cnt < ndebopts; ++cnt)
2161         _dl_printf ("  %.*s%s%s\n", debopts[cnt].len, debopts[cnt].name,
2162                     "         " + debopts[cnt].len - 3,
2163                     debopts[cnt].helptext);
2164
2165       _dl_printf ("\n\
2166 To direct the debugging output into a file instead of standard output\n\
2167 a filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n");
2168       _exit (0);
2169     }
2170 }
2171 \f
2172 /* Process all environments variables the dynamic linker must recognize.
2173    Since all of them start with `LD_' we are a bit smarter while finding
2174    all the entries.  */
2175 extern char **_environ attribute_hidden;
2176
2177
2178 static void
2179 process_envvars (enum mode *modep)
2180 {
2181   char **runp = _environ;
2182   char *envline;
2183   enum mode mode = normal;
2184   char *debug_output = NULL;
2185
2186   /* This is the default place for profiling data file.  */
2187   GLRO(dl_profile_output)
2188     = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure) ? 9 : 0];
2189
2190   while ((envline = _dl_next_ld_env_entry (&runp)) != NULL)
2191     {
2192       size_t len = 0;
2193
2194       while (envline[len] != '\0' && envline[len] != '=')
2195         ++len;
2196
2197       if (envline[len] != '=')
2198         /* This is a "LD_" variable at the end of the string without
2199            a '=' character.  Ignore it since otherwise we will access
2200            invalid memory below.  */
2201         continue;
2202
2203       switch (len)
2204         {
2205         case 4:
2206           /* Warning level, verbose or not.  */
2207           if (memcmp (envline, "WARN", 4) == 0)
2208             GLRO(dl_verbose) = envline[5] != '\0';
2209           break;
2210
2211         case 5:
2212           /* Debugging of the dynamic linker?  */
2213           if (memcmp (envline, "DEBUG", 5) == 0)
2214             process_dl_debug (&envline[6]);
2215           break;
2216
2217         case 7:
2218           /* Print information about versions.  */
2219           if (memcmp (envline, "VERBOSE", 7) == 0)
2220             {
2221               version_info = envline[8] != '\0';
2222               break;
2223             }
2224
2225           /* List of objects to be preloaded.  */
2226           if (memcmp (envline, "PRELOAD", 7) == 0)
2227             {
2228               preloadlist = &envline[8];
2229               break;
2230             }
2231
2232           /* Which shared object shall be profiled.  */
2233           if (memcmp (envline, "PROFILE", 7) == 0 && envline[8] != '\0')
2234             GLRO(dl_profile) = &envline[8];
2235           break;
2236
2237         case 8:
2238           /* Do we bind early?  */
2239           if (memcmp (envline, "BIND_NOW", 8) == 0)
2240             {
2241               GLRO(dl_lazy) = envline[9] == '\0';
2242               break;
2243             }
2244           if (memcmp (envline, "BIND_NOT", 8) == 0)
2245             GLRO(dl_bind_not) = envline[9] != '\0';
2246           break;
2247
2248         case 9:
2249           /* Test whether we want to see the content of the auxiliary
2250              array passed up from the kernel.  */
2251           if (memcmp (envline, "SHOW_AUXV", 9) == 0)
2252             _dl_show_auxv ();
2253           break;
2254
2255         case 10:
2256           /* Mask for the important hardware capabilities.  */
2257           if (memcmp (envline, "HWCAP_MASK", 10) == 0)
2258             GLRO(dl_hwcap_mask) = __strtoul_internal (&envline[11], NULL,
2259                                                       0, 0);
2260           break;
2261
2262         case 11:
2263           /* Path where the binary is found.  */
2264           if (!INTUSE(__libc_enable_secure)
2265               && memcmp (envline, "ORIGIN_PATH", 11) == 0)
2266             GLRO(dl_origin_path) = &envline[12];
2267           break;
2268
2269         case 12:
2270           /* The library search path.  */
2271           if (memcmp (envline, "LIBRARY_PATH", 12) == 0)
2272             {
2273               library_path = &envline[13];
2274               break;
2275             }
2276
2277           /* Where to place the profiling data file.  */
2278           if (memcmp (envline, "DEBUG_OUTPUT", 12) == 0)
2279             {
2280               debug_output = &envline[13];
2281               break;
2282             }
2283
2284           if (memcmp (envline, "DYNAMIC_WEAK", 12) == 0)
2285             GLRO(dl_dynamic_weak) = 1;
2286           break;
2287
2288         case 13:
2289           /* We might have some extra environment variable with length 13
2290              to handle.  */
2291 #ifdef EXTRA_LD_ENVVARS_13
2292           EXTRA_LD_ENVVARS_13
2293 #endif
2294           if (!INTUSE(__libc_enable_secure)
2295               && memcmp (envline, "USE_LOAD_BIAS", 13) == 0)
2296             GLRO(dl_use_load_bias) = envline[14] == '1' ? -1 : 0;
2297           break;
2298
2299         case 14:
2300           /* Where to place the profiling data file.  */
2301           if (!INTUSE(__libc_enable_secure)
2302               && memcmp (envline, "PROFILE_OUTPUT", 14) == 0
2303               && envline[15] != '\0')
2304             GLRO(dl_profile_output) = &envline[15];
2305           break;
2306
2307         case 16:
2308           /* The mode of the dynamic linker can be set.  */
2309           if (memcmp (envline, "TRACE_PRELINKING", 16) == 0)
2310             {
2311               mode = trace;
2312               GLRO(dl_verbose) = 1;
2313               GLRO(dl_debug_mask) |= DL_DEBUG_PRELINK;
2314               GLRO(dl_trace_prelink) = &envline[17];
2315             }
2316           break;
2317
2318         case 20:
2319           /* The mode of the dynamic linker can be set.  */
2320           if (memcmp (envline, "TRACE_LOADED_OBJECTS", 20) == 0)
2321             mode = trace;
2322           break;
2323
2324           /* We might have some extra environment variable to handle.  This
2325              is tricky due to the pre-processing of the length of the name
2326              in the switch statement here.  The code here assumes that added
2327              environment variables have a different length.  */
2328 #ifdef EXTRA_LD_ENVVARS
2329           EXTRA_LD_ENVVARS
2330 #endif
2331         }
2332     }
2333
2334   /* The caller wants this information.  */
2335   *modep = mode;
2336
2337   /* Extra security for SUID binaries.  Remove all dangerous environment
2338      variables.  */
2339   if (__builtin_expect (INTUSE(__libc_enable_secure), 0))
2340     {
2341       static const char unsecure_envvars[] =
2342 #ifdef EXTRA_UNSECURE_ENVVARS
2343         EXTRA_UNSECURE_ENVVARS
2344 #endif
2345         UNSECURE_ENVVARS;
2346       const char *nextp;
2347
2348       nextp = unsecure_envvars;
2349       do
2350         {
2351           unsetenv (nextp);
2352           /* We could use rawmemchr but this need not be fast.  */
2353           nextp = (char *) (strchr) (nextp, '\0') + 1;
2354         }
2355       while (*nextp != '\0');
2356
2357       if (__access ("/etc/suid-debug", F_OK) != 0)
2358         unsetenv ("MALLOC_CHECK_");
2359     }
2360   /* If we have to run the dynamic linker in debugging mode and the
2361      LD_DEBUG_OUTPUT environment variable is given, we write the debug
2362      messages to this file.  */
2363   else if (any_debug && debug_output != NULL)
2364     {
2365 #ifdef O_NOFOLLOW
2366       const int flags = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
2367 #else
2368       const int flags = O_WRONLY | O_APPEND | O_CREAT;
2369 #endif
2370       size_t name_len = strlen (debug_output);
2371       char buf[name_len + 12];
2372       char *startp;
2373
2374       buf[name_len + 11] = '\0';
2375       startp = _itoa (__getpid (), &buf[name_len + 11], 10, 0);
2376       *--startp = '.';
2377       startp = memcpy (startp - name_len, debug_output, name_len);
2378
2379       GLRO(dl_debug_fd) = __open (startp, flags, DEFFILEMODE);
2380       if (GLRO(dl_debug_fd) == -1)
2381         /* We use standard output if opening the file failed.  */
2382         GLRO(dl_debug_fd) = STDOUT_FILENO;
2383     }
2384 }
2385
2386
2387 /* Print the various times we collected.  */
2388 static void
2389 __attribute ((noinline))
2390 print_statistics (hp_timing_t *rtld_total_timep)
2391 {
2392 #ifndef HP_TIMING_NONAVAIL
2393   char buf[200];
2394   char *cp;
2395   char *wp;
2396
2397   /* Total time rtld used.  */
2398   if (HP_TIMING_AVAIL)
2399     {
2400       HP_TIMING_PRINT (buf, sizeof (buf), *rtld_total_timep);
2401       _dl_debug_printf ("\nruntime linker statistics:\n"
2402                         "  total startup time in dynamic loader: %s\n", buf);
2403
2404       /* Print relocation statistics.  */
2405       char pbuf[30];
2406       HP_TIMING_PRINT (buf, sizeof (buf), relocate_time);
2407       cp = _itoa ((1000ULL * relocate_time) / *rtld_total_timep,
2408                   pbuf + sizeof (pbuf), 10, 0);
2409       wp = pbuf;
2410       switch (pbuf + sizeof (pbuf) - cp)
2411         {
2412         case 3:
2413           *wp++ = *cp++;
2414         case 2:
2415           *wp++ = *cp++;
2416         case 1:
2417           *wp++ = '.';
2418           *wp++ = *cp++;
2419         }
2420       *wp = '\0';
2421       _dl_debug_printf ("\
2422             time needed for relocation: %s (%s%%)\n", buf, pbuf);
2423     }
2424 #endif
2425
2426   unsigned long int num_relative_relocations = 0;
2427   struct r_scope_elem *scope = &GL(dl_loaded)->l_searchlist;
2428   unsigned int i;
2429
2430   for (i = 0; i < scope->r_nlist; i++)
2431     {
2432       struct link_map *l = scope->r_list [i];
2433
2434       if (!l->l_addr)
2435         continue;
2436
2437       if (l->l_info[VERSYMIDX (DT_RELCOUNT)])
2438         num_relative_relocations += l->l_info[VERSYMIDX (DT_RELCOUNT)]->d_un.d_val;
2439       if (l->l_info[VERSYMIDX (DT_RELACOUNT)])
2440         num_relative_relocations += l->l_info[VERSYMIDX (DT_RELACOUNT)]->d_un.d_val;
2441     }
2442
2443   _dl_debug_printf ("                 number of relocations: %lu\n"
2444                     "      number of relocations from cache: %lu\n"
2445                     "        number of relative relocations: %lu\n",
2446                     GL(dl_num_relocations),
2447                     GL(dl_num_cache_relocations),
2448                     num_relative_relocations);
2449
2450 #ifndef HP_TIMING_NONAVAIL
2451   /* Time spend while loading the object and the dependencies.  */
2452   if (HP_TIMING_AVAIL)
2453     {
2454       char pbuf[30];
2455       HP_TIMING_PRINT (buf, sizeof (buf), load_time);
2456       cp = _itoa ((1000ULL * load_time) / *rtld_total_timep,
2457                   pbuf + sizeof (pbuf), 10, 0);
2458       wp = pbuf;
2459       switch (pbuf + sizeof (pbuf) - cp)
2460         {
2461         case 3:
2462           *wp++ = *cp++;
2463         case 2:
2464           *wp++ = *cp++;
2465         case 1:
2466           *wp++ = '.';
2467           *wp++ = *cp++;
2468         }
2469       *wp = '\0';
2470       _dl_debug_printf ("\
2471            time needed to load objects: %s (%s%%)\n",
2472                                 buf, pbuf);
2473     }
2474 #endif
2475 }