5ed5128ef577eb68d886b20fbbd2f0ba5f60114e
[kopensolaris-gnu/glibc.git] / elf / dl-load.c
1 /* Map in a shared object's segments from the file.
2    Copyright (C) 1995, 1996, 1997, 1998, 1999 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 Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    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    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #include <elf.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <elf/ldsodefs.h>
27 #include <sys/mman.h>
28 #include <sys/param.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 #include "dynamic-link.h"
32 #include <stdio-common/_itoa.h>
33
34 #include <dl-dst.h>
35
36 /* On some systems, no flag bits are given to specify file mapping.  */
37 #ifndef MAP_FILE
38 #define MAP_FILE        0
39 #endif
40
41 /* The right way to map in the shared library files is MAP_COPY, which
42    makes a virtual copy of the data at the time of the mmap call; this
43    guarantees the mapped pages will be consistent even if the file is
44    overwritten.  Some losing VM systems like Linux's lack MAP_COPY.  All we
45    get is MAP_PRIVATE, which copies each page when it is modified; this
46    means if the file is overwritten, we may at some point get some pages
47    from the new version after starting with pages from the old version.  */
48 #ifndef MAP_COPY
49 #define MAP_COPY        MAP_PRIVATE
50 #endif
51
52 /* Some systems link their relocatable objects for another base address
53    than 0.  We want to know the base address for these such that we can
54    subtract this address from the segment addresses during mapping.
55    This results in a more efficient address space usage.  Defaults to
56    zero for almost all systems.  */
57 #ifndef MAP_BASE_ADDR
58 #define MAP_BASE_ADDR(l)        0
59 #endif
60
61
62 #include <endian.h>
63 #if BYTE_ORDER == BIG_ENDIAN
64 #define byteorder ELFDATA2MSB
65 #define byteorder_name "big-endian"
66 #elif BYTE_ORDER == LITTLE_ENDIAN
67 #define byteorder ELFDATA2LSB
68 #define byteorder_name "little-endian"
69 #else
70 #error "Unknown BYTE_ORDER " BYTE_ORDER
71 #define byteorder ELFDATANONE
72 #endif
73
74 #define STRING(x) __STRING (x)
75
76 #ifdef MAP_ANON
77 /* The fd is not examined when using MAP_ANON.  */
78 #define ANONFD -1
79 #else
80 int _dl_zerofd = -1;
81 #define ANONFD _dl_zerofd
82 #endif
83
84 /* Handle situations where we have a preferred location in memory for
85    the shared objects.  */
86 #ifdef ELF_PREFERRED_ADDRESS_DATA
87 ELF_PREFERRED_ADDRESS_DATA;
88 #endif
89 #ifndef ELF_PREFERRED_ADDRESS
90 #define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) (mapstartpref)
91 #endif
92 #ifndef ELF_FIXED_ADDRESS
93 #define ELF_FIXED_ADDRESS(loader, mapstart) ((void) 0)
94 #endif
95
96 size_t _dl_pagesize;
97
98 extern const char *_dl_platform;
99 extern size_t _dl_platformlen;
100
101 /* This is the decomposed LD_LIBRARY_PATH search path.  */
102 static struct r_search_path_elem **env_path_list;
103
104 /* List of the hardware capabilities we might end up using.  */
105 static const struct r_strlenpair *capstr;
106 static size_t ncapstr;
107 static size_t max_capstrlen;
108
109 const unsigned char _dl_pf_to_prot[8] =
110 {
111   [0] = PROT_NONE,
112   [PF_R] = PROT_READ,
113   [PF_W] = PROT_WRITE,
114   [PF_R | PF_W] = PROT_READ | PROT_WRITE,
115   [PF_X] = PROT_EXEC,
116   [PF_R | PF_X] = PROT_READ | PROT_EXEC,
117   [PF_W | PF_X] = PROT_WRITE | PROT_EXEC,
118   [PF_R | PF_W | PF_X] = PROT_READ | PROT_WRITE | PROT_EXEC
119 };
120
121
122 /* Get the generated information about the trusted directories.  */
123 #include "trusted-dirs.h"
124
125 static const char system_dirs[] = SYSTEM_DIRS;
126 static const size_t system_dirs_len[] =
127 {
128   SYSTEM_DIRS_LEN
129 };
130
131 /* This function has no public prototype.  */
132 extern ssize_t __libc_read (int, void *, size_t);
133
134
135 /* Local version of `strdup' function.  */
136 static inline char *
137 local_strdup (const char *s)
138 {
139   size_t len = strlen (s) + 1;
140   void *new = malloc (len);
141
142   if (new == NULL)
143     return NULL;
144
145   return (char *) memcpy (new, s, len);
146 }
147
148
149 size_t
150 _dl_dst_count (const char *name, int is_path)
151 {
152   size_t cnt = 0;
153
154   do
155     {
156       size_t len = 1;
157
158       /* $ORIGIN is not expanded for SUID/GUID programs.  */
159       if ((((!__libc_enable_secure
160              && strncmp (&name[1], "ORIGIN", 6) == 0 && (len = 7) != 0)
161             || (strncmp (&name[1], "PLATFORM", 8) == 0 && (len = 9) != 0))
162            && (name[len] == '\0' || name[len] == '/'
163                || (is_path && name[len] == ':')))
164           || (name[1] == '{'
165               && ((!__libc_enable_secure
166                    && strncmp (&name[2], "ORIGIN}", 7) == 0 && (len = 9) != 0)
167                   || (strncmp (&name[2], "PLATFORM}", 9) == 0
168                       && (len = 11) != 0))))
169         ++cnt;
170
171       name = strchr (name + len, '$');
172     }
173   while (name != NULL);
174
175   return cnt;
176 }
177
178
179 char *
180 _dl_dst_substitute (struct link_map *l, const char *name, char *result,
181                     int is_path)
182 {
183   char *last_elem, *wp;
184
185   /* Now fill the result path.  While copying over the string we keep
186      track of the start of the last path element.  When we come accross
187      a DST we copy over the value or (if the value is not available)
188      leave the entire path element out.  */
189   last_elem = wp = result;
190
191   do
192     {
193       if (*name == '$')
194         {
195           const char *repl;
196           size_t len;
197
198           if ((((strncmp (&name[1], "ORIGIN", 6) == 0 && (len = 7) != 0)
199                 || (strncmp (&name[1], "PLATFORM", 8) == 0 && (len = 9) != 0))
200                && (name[len] == '\0' || name[len] == '/'
201                    || (is_path && name[len] == ':')))
202               || (name[1] == '{'
203                   && ((strncmp (&name[2], "ORIGIN}", 7) == 0 && (len = 9) != 0)
204                       || (strncmp (&name[2], "PLATFORM}", 9) == 0
205                           && (len = 11) != 0))))
206             {
207               repl = ((len == 7 || name[2] == 'O')
208                       ? (__libc_enable_secure ? NULL : l->l_origin)
209                       : _dl_platform);
210
211               if (repl != NULL && repl != (const char *) -1)
212                 {
213                   wp = __stpcpy (wp, repl);
214                   name += len;
215                 }
216               else
217                 {
218                   /* We cannot use this path element, the value of the
219                      replacement is unknown.  */
220                   wp = last_elem;
221                   name += len;
222                   while (*name != '\0' && (!is_path || *name != ':'))
223                     ++name;
224                 }
225             }
226           else
227             /* No DST we recognize.  */
228             *wp++ = *name++;
229         }
230       else if (is_path && *name == ':')
231         {
232           *wp++ = *name++;
233           last_elem = wp;
234         }
235       else
236         *wp++ = *name++;
237     }
238   while (*name != '\0');
239
240   *wp = '\0';
241
242   return result;
243 }
244
245
246 /* Return copy of argument with all recognized dynamic string tokens
247    ($ORIGIN and $PLATFORM for now) replaced.  On some platforms it
248    might not be possible to determine the path from which the object
249    belonging to the map is loaded.  In this case the path element
250    containing $ORIGIN is left out.  */
251 static char *
252 expand_dynamic_string_token (struct link_map *l, const char *s)
253 {
254   /* We make two runs over the string.  First we determine how large the
255      resulting string is and then we copy it over.  Since this is now
256      frequently executed operation we are looking here not for performance
257      but rather for code size.  */
258   size_t cnt;
259   size_t total;
260   char *result;
261
262   /* Determine the nubmer of DST elements.  */
263   cnt = DL_DST_COUNT (s, 1);
264
265   /* If we do not have to replace anything simply copy the string.  */
266   if (cnt == 0)
267     return local_strdup (s);
268
269   /* Determine the length of the substituted string.  */
270   total = DL_DST_REQUIRED (l, s, strlen (s), cnt);
271
272   /* Allocate the necessary memory.  */
273   result = (char *) malloc (total + 1);
274   if (result == NULL)
275     return NULL;
276
277   return DL_DST_SUBSTITUTE (l, s, result, 1);
278 }
279
280
281 /* Add `name' to the list of names for a particular shared object.
282    `name' is expected to have been allocated with malloc and will
283    be freed if the shared object already has this name.
284    Returns false if the object already had this name.  */
285 static void
286 internal_function
287 add_name_to_object (struct link_map *l, const char *name)
288 {
289   struct libname_list *lnp, *lastp;
290   struct libname_list *newname;
291   size_t name_len;
292
293   lastp = NULL;
294   for (lnp = l->l_libname; lnp != NULL; lastp = lnp, lnp = lnp->next)
295     if (strcmp (name, lnp->name) == 0)
296       return;
297
298   name_len = strlen (name) + 1;
299   newname = malloc (sizeof *newname + name_len);
300   if (newname == NULL)
301     {
302       /* No more memory.  */
303       _dl_signal_error (ENOMEM, name, "cannot allocate name record");
304       return;
305     }
306   /* The object should have a libname set from _dl_new_object.  */
307   assert (lastp != NULL);
308
309   newname->name = memcpy (newname + 1, name, name_len);
310   newname->next = NULL;
311   lastp->next = newname;
312 }
313
314 /* All known directories in sorted order.  */
315 static struct r_search_path_elem *all_dirs;
316
317 /* Standard search directories.  */
318 static struct r_search_path_elem **rtld_search_dirs;
319
320 static size_t max_dirnamelen;
321
322 static inline struct r_search_path_elem **
323 fillin_rpath (char *rpath, struct r_search_path_elem **result, const char *sep,
324               int check_trusted, const char *what, const char *where)
325 {
326   char *cp;
327   size_t nelems = 0;
328
329   while ((cp = __strsep (&rpath, sep)) != NULL)
330     {
331       struct r_search_path_elem *dirp;
332       size_t len = strlen (cp);
333
334       /* `strsep' can pass an empty string.  This has to be
335          interpreted as `use the current directory'. */
336       if (len == 0)
337         {
338           static const char curwd[] = "./";
339           cp = (char *) curwd;
340         }
341
342       /* Remove trailing slashes (except for "/").  */
343       while (len > 1 && cp[len - 1] == '/')
344         --len;
345
346       /* Now add one if there is none so far.  */
347       if (len > 0 && cp[len - 1] != '/')
348         cp[len++] = '/';
349
350       /* Make sure we don't use untrusted directories if we run SUID.  */
351       if (check_trusted)
352         {
353           const char *trun = system_dirs;
354           size_t idx;
355
356           /* All trusted directories must be complete names.  */
357           if (cp[0] != '/')
358             continue;
359
360           for (idx = 0;
361                idx < sizeof (system_dirs_len) / sizeof (system_dirs_len[0]);
362                ++idx)
363             {
364               if (len == system_dirs_len[idx] && memcmp (trun, cp, len) == 0)
365                 /* Found it.  */
366                 break;
367
368               trun += system_dirs_len[idx] + 1;
369             }
370
371           if (idx == sizeof (system_dirs_len) / sizeof (system_dirs_len[0]))
372             /* It's no trusted directory, skip it.  */
373             continue;
374         }
375
376       /* See if this directory is already known.  */
377       for (dirp = all_dirs; dirp != NULL; dirp = dirp->next)
378         if (dirp->dirnamelen == len && memcmp (cp, dirp->dirname, len) == 0)
379           break;
380
381       if (dirp != NULL)
382         {
383           /* It is available, see whether it's on our own list.  */
384           size_t cnt;
385           for (cnt = 0; cnt < nelems; ++cnt)
386             if (result[cnt] == dirp)
387               break;
388
389           if (cnt == nelems)
390             result[nelems++] = dirp;
391         }
392       else
393         {
394           size_t cnt;
395
396           /* It's a new directory.  Create an entry and add it.  */
397           dirp = (struct r_search_path_elem *)
398             malloc (sizeof (*dirp) + ncapstr * sizeof (enum r_dir_status));
399           if (dirp == NULL)
400             _dl_signal_error (ENOMEM, NULL,
401                               "cannot create cache for search path");
402
403           dirp->dirname = cp;
404           dirp->dirnamelen = len;
405
406           if (len > max_dirnamelen)
407             max_dirnamelen = len;
408
409           /* We have to make sure all the relative directories are never
410              ignored.  The current directory might change and all our
411              saved information would be void.  */
412           if (cp[0] != '/')
413             for (cnt = 0; cnt < ncapstr; ++cnt)
414               dirp->status[cnt] = existing;
415           else
416             for (cnt = 0; cnt < ncapstr; ++cnt)
417               dirp->status[cnt] = unknown;
418
419           dirp->what = what;
420           dirp->where = where;
421
422           dirp->next = all_dirs;
423           all_dirs = dirp;
424
425           /* Put it in the result array.  */
426           result[nelems++] = dirp;
427         }
428     }
429
430   /* Terminate the array.  */
431   result[nelems] = NULL;
432
433   return result;
434 }
435
436
437 static struct r_search_path_elem **
438 internal_function
439 decompose_rpath (const char *rpath, struct link_map *l)
440 {
441   /* Make a copy we can work with.  */
442   const char *where = l->l_name;
443   char *copy;
444   char *cp;
445   struct r_search_path_elem **result;
446   size_t nelems;
447
448   /* First see whether we must forget the RPATH from this object.  */
449   if (_dl_inhibit_rpath != NULL && !__libc_enable_secure)
450     {
451       const char *found = strstr (_dl_inhibit_rpath, where);
452       if (found != NULL)
453         {
454           size_t len = strlen (where);
455           if ((found == _dl_inhibit_rpath || found[-1] == ':')
456               && (found[len] == '\0' || found[len] == ':'))
457             {
458               /* This object is on the list of objects for which the RPATH
459                  must not be used.  */
460               result = (struct r_search_path_elem **)
461                 malloc (sizeof (*result));
462               if (result == NULL)
463                 _dl_signal_error (ENOMEM, NULL,
464                                   "cannot create cache for search path");
465               result[0] = NULL;
466
467               return result;
468             }
469         }
470     }
471
472   /* Make a writable copy.  At the same time expand possible dynamic
473      string tokens.  */
474   copy = expand_dynamic_string_token (l, rpath);
475   if (copy == NULL)
476     _dl_signal_error (ENOMEM, NULL, "cannot create RPATH copy");
477
478   /* Count the number of necessary elements in the result array.  */
479   nelems = 0;
480   for (cp = copy; *cp != '\0'; ++cp)
481     if (*cp == ':')
482       ++nelems;
483
484   /* Allocate room for the result.  NELEMS + 1 is an upper limit for the
485      number of necessary entries.  */
486   result = (struct r_search_path_elem **) malloc ((nelems + 1 + 1)
487                                                   * sizeof (*result));
488   if (result == NULL)
489     _dl_signal_error (ENOMEM, NULL, "cannot create cache for search path");
490
491   return fillin_rpath (copy, result, ":", 0, "RPATH", where);
492 }
493
494
495 void
496 internal_function
497 _dl_init_paths (const char *llp)
498 {
499   size_t idx;
500   const char *strp;
501   struct r_search_path_elem *pelem, **aelem;
502   size_t round_size;
503 #ifdef PIC
504   struct link_map *l;
505 #endif
506
507   /* Fill in the information about the application's RPATH and the
508      directories addressed by the LD_LIBRARY_PATH environment variable.  */
509
510   /* Get the capabilities.  */
511   capstr = _dl_important_hwcaps (_dl_platform, _dl_platformlen,
512                                  &ncapstr, &max_capstrlen);
513
514   /* First set up the rest of the default search directory entries.  */
515   aelem = rtld_search_dirs = (struct r_search_path_elem **)
516     malloc ((sizeof (system_dirs_len) / sizeof (system_dirs_len[0]))
517              * sizeof (struct r_search_path_elem *));
518   if (rtld_search_dirs == NULL)
519     _dl_signal_error (ENOMEM, NULL, "cannot create search path array");
520
521   round_size = ((2 * sizeof (struct r_search_path_elem) - 1
522                  + ncapstr * sizeof (enum r_dir_status))
523                 / sizeof (struct r_search_path_elem));
524
525   rtld_search_dirs[0] = (struct r_search_path_elem *)
526     malloc ((sizeof (system_dirs) / sizeof (system_dirs[0]) - 1)
527             * round_size * sizeof (struct r_search_path_elem));
528   if (rtld_search_dirs[0] == NULL)
529     _dl_signal_error (ENOMEM, NULL, "cannot create cache for search path");
530
531   pelem = all_dirs = rtld_search_dirs[0];
532   strp = system_dirs;
533   idx = 0;
534
535   do
536     {
537       size_t cnt;
538
539       *aelem++ = pelem;
540
541       pelem->what = "system search path";
542       pelem->where = NULL;
543
544       pelem->dirname = strp;
545       pelem->dirnamelen = system_dirs_len[idx];
546       strp += system_dirs_len[idx] + 1;
547
548       if (pelem->dirname[0] != '/')
549         for (cnt = 0; cnt < ncapstr; ++cnt)
550           pelem->status[cnt] = existing;
551       else
552         for (cnt = 0; cnt < ncapstr; ++cnt)
553           pelem->status[cnt] = unknown;
554
555       pelem->next = (++idx == (sizeof (system_dirs_len)
556                                / sizeof (system_dirs_len[0]))
557                      ? NULL : (pelem + round_size));
558
559       pelem += round_size;
560     }
561   while (idx < sizeof (system_dirs_len) / sizeof (system_dirs_len[0]));
562
563   max_dirnamelen = SYSTEM_DIRS_MAX_LEN;
564   *aelem = NULL;
565
566 #ifdef PIC
567   /* This points to the map of the main object.  */
568   l = _dl_loaded;
569   if (l != NULL)
570     {
571       assert (l->l_type != lt_loaded);
572
573       if (l->l_info[DT_RPATH])
574         /* Allocate room for the search path and fill in information
575            from RPATH.  */
576         l->l_rpath_dirs =
577           decompose_rpath ((const void *) (l->l_info[DT_STRTAB]->d_un.d_ptr
578                                            + l->l_info[DT_RPATH]->d_un.d_val),
579                            l);
580       else
581         l->l_rpath_dirs = NULL;
582     }
583 #endif  /* PIC */
584
585   if (llp != NULL && *llp != '\0')
586     {
587       size_t nllp;
588       const char *cp = llp;
589
590       /* Decompose the LD_LIBRARY_PATH contents.  First determine how many
591          elements it has.  */
592       nllp = 1;
593       while (*cp)
594         {
595           if (*cp == ':' || *cp == ';')
596             ++nllp;
597           ++cp;
598         }
599
600       env_path_list = (struct r_search_path_elem **)
601         malloc ((nllp + 1) * sizeof (struct r_search_path_elem *));
602       if (env_path_list == NULL)
603         _dl_signal_error (ENOMEM, NULL,
604                           "cannot create cache for search path");
605
606       (void) fillin_rpath (local_strdup (llp), env_path_list, ":;",
607                            __libc_enable_secure, "LD_LIBRARY_PATH", NULL);
608     }
609 }
610
611
612 /* Think twice before changing anything in this function.  It is placed
613    here and prepared using the `alloca' magic to prevent it from being
614    inlined.  The function is only called in case of an error.  But then
615    performance does not count.  The function used to be "inlinable" and
616    the compiled did so all the time.  This increased the code size for
617    absolutely no good reason.  */
618 #define LOSE(code, s) lose (code, fd, name, realname, l, s)
619 static void
620 __attribute__ ((noreturn))
621 lose (int code, int fd, const char *name, char *realname, struct link_map *l,
622       const char *msg)
623 {
624   /* The use of `alloca' here looks ridiculous but it helps.  The goal
625      is to avoid the function from being inlined.  There is no official
626      way to do this so we use this trick.  gcc never inlines functions
627      which use `alloca'.  */
628   int *a = alloca (sizeof (int));
629   a[0] = fd;
630   (void) __close (a[0]);
631   if (l != NULL)
632     {
633       /* Remove the stillborn object from the list and free it.  */
634       if (l->l_prev)
635         l->l_prev->l_next = l->l_next;
636       if (l->l_next)
637         l->l_next->l_prev = l->l_prev;
638       free (l);
639     }
640   free (realname);
641   _dl_signal_error (code, name, msg);
642 }
643
644
645 /* Map in the shared object NAME, actually located in REALNAME, and already
646    opened on FD.  */
647
648 #ifndef EXTERNAL_MAP_FROM_FD
649 static
650 #endif
651 struct link_map *
652 _dl_map_object_from_fd (const char *name, int fd, char *realname,
653                         struct link_map *loader, int l_type)
654 {
655   /* This is the expected ELF header.  */
656 #define ELF32_CLASS ELFCLASS32
657 #define ELF64_CLASS ELFCLASS64
658   static const unsigned char expected[EI_PAD] =
659   {
660     [EI_MAG0] = ELFMAG0,
661     [EI_MAG1] = ELFMAG1,
662     [EI_MAG2] = ELFMAG2,
663     [EI_MAG3] = ELFMAG3,
664     [EI_CLASS] = ELFW(CLASS),
665     [EI_DATA] = byteorder,
666     [EI_VERSION] = EV_CURRENT,
667     [EI_OSABI] = ELFOSABI_SYSV,
668     [EI_ABIVERSION] = 0
669   };
670   struct link_map *l = NULL;
671
672   inline caddr_t map_segment (ElfW(Addr) mapstart, size_t len,
673                               int prot, int fixed, off_t offset)
674     {
675       caddr_t mapat = __mmap ((caddr_t) mapstart, len, prot,
676                               fixed|MAP_COPY|MAP_FILE,
677                               fd, offset);
678       if (mapat == MAP_FAILED)
679         LOSE (errno, "failed to map segment from shared object");
680       return mapat;
681     }
682
683   const ElfW(Ehdr) *header;
684   const ElfW(Phdr) *phdr;
685   const ElfW(Phdr) *ph;
686   size_t maplength;
687   int type;
688   char *readbuf;
689   ssize_t readlength;
690   struct stat st;
691
692   /* Get file information.  */
693   if (__fxstat (_STAT_VER, fd, &st) < 0)
694     LOSE (errno, "cannot stat shared object");
695
696   /* Look again to see if the real name matched another already loaded.  */
697   for (l = _dl_loaded; l; l = l->l_next)
698     if (l->l_ino == st.st_ino && l->l_dev == st.st_dev)
699       {
700         /* The object is already loaded.
701            Just bump its reference count and return it.  */
702         __close (fd);
703
704         /* If the name is not in the list of names for this object add
705            it.  */
706         free (realname);
707         add_name_to_object (l, name);
708         ++l->l_opencount;
709         return l;
710       }
711
712   /* Print debugging message.  */
713   if (_dl_debug_files)
714     _dl_debug_message (1, "file=", name, ";  generating link map\n", NULL);
715
716   /* Read the header directly.  */
717   readbuf = alloca (_dl_pagesize);
718   readlength = __libc_read (fd, readbuf, _dl_pagesize);
719   if (readlength < (ssize_t) sizeof (*header))
720     LOSE (errno, "cannot read file data");
721   header = (void *) readbuf;
722
723   /* Check the header for basic validity.  */
724   if (memcmp (header->e_ident, expected, EI_PAD) != 0)
725     {
726       /* Something is wrong.  */
727       if (*(Elf32_Word *) &header->e_ident !=
728 #if BYTE_ORDER == LITTLE_ENDIAN
729           ((ELFMAG0 << (EI_MAG0 * 8)) |
730            (ELFMAG1 << (EI_MAG1 * 8)) |
731            (ELFMAG2 << (EI_MAG2 * 8)) |
732            (ELFMAG3 << (EI_MAG3 * 8)))
733 #else
734           ((ELFMAG0 << (EI_MAG3 * 8)) |
735            (ELFMAG1 << (EI_MAG2 * 8)) |
736            (ELFMAG2 << (EI_MAG1 * 8)) |
737            (ELFMAG3 << (EI_MAG0 * 8)))
738 #endif
739           )
740         LOSE (0, "invalid ELF header");
741       if (header->e_ident[EI_CLASS] != ELFW(CLASS))
742         LOSE (0, "ELF file class not " STRING(__ELF_NATIVE_CLASS) "-bit");
743       if (header->e_ident[EI_DATA] != byteorder)
744         LOSE (0, "ELF file data encoding not " byteorder_name);
745       if (header->e_ident[EI_VERSION] != EV_CURRENT)
746         LOSE (0, "ELF file version ident not " STRING(EV_CURRENT));
747       /* XXX We should be able so set system specific versions which are
748          allowed here.  */
749       if (header->e_ident[EI_OSABI] != ELFOSABI_SYSV)
750         LOSE (0, "ELF file OS ABI not " STRING(ELFOSABI_SYSV));
751       if (header->e_ident[EI_ABIVERSION] != 0)
752         LOSE (0, "ELF file ABI version not 0");
753       LOSE (0, "internal error");
754     }
755
756   if (header->e_version != EV_CURRENT)
757     LOSE (0, "ELF file version not " STRING(EV_CURRENT));
758   if (! elf_machine_matches_host (header->e_machine))
759     LOSE (0, "ELF file machine architecture not " ELF_MACHINE_NAME);
760   if (header->e_phentsize != sizeof (ElfW(Phdr)))
761     LOSE (0, "ELF file's phentsize not the expected size");
762
763 #ifndef MAP_ANON
764 # define MAP_ANON 0
765   if (_dl_zerofd == -1)
766     {
767       _dl_zerofd = _dl_sysdep_open_zero_fill ();
768       if (_dl_zerofd == -1)
769         {
770           __close (fd);
771           _dl_signal_error (errno, NULL, "cannot open zero fill device");
772         }
773     }
774 #endif
775
776   /* Enter the new object in the list of loaded objects.  */
777   l = _dl_new_object (realname, name, l_type, loader);
778   if (! l)
779     LOSE (ENOMEM, "cannot create shared object descriptor");
780   l->l_opencount = 1;
781
782   /* Extract the remaining details we need from the ELF header
783      and then read in the program header table.  */
784   l->l_entry = header->e_entry;
785   type = header->e_type;
786   l->l_phnum = header->e_phnum;
787
788   maplength = header->e_phnum * sizeof (ElfW(Phdr));
789   if (header->e_phoff + maplength <= readlength)
790     phdr = (void *) (readbuf + header->e_phoff);
791   else
792     {
793       phdr = alloca (maplength);
794       __lseek (fd, SEEK_SET, header->e_phoff);
795       if (__libc_read (fd, (void *) phdr, maplength) != maplength)
796         LOSE (errno, "cannot read file data");
797     }
798
799   {
800     /* Scan the program header table, collecting its load commands.  */
801     struct loadcmd
802       {
803         ElfW(Addr) mapstart, mapend, dataend, allocend;
804         off_t mapoff;
805         int prot;
806       } loadcmds[l->l_phnum], *c;
807     size_t nloadcmds = 0;
808
809     /* The struct is initialized to zero so this is not necessary:
810     l->l_ld = 0;
811     l->l_phdr = 0;
812     l->l_addr = 0; */
813     for (ph = phdr; ph < &phdr[l->l_phnum]; ++ph)
814       switch (ph->p_type)
815         {
816           /* These entries tell us where to find things once the file's
817              segments are mapped in.  We record the addresses it says
818              verbatim, and later correct for the run-time load address.  */
819         case PT_DYNAMIC:
820           l->l_ld = (void *) ph->p_vaddr;
821           break;
822         case PT_PHDR:
823           l->l_phdr = (void *) ph->p_vaddr;
824           break;
825
826         case PT_LOAD:
827           /* A load command tells us to map in part of the file.
828              We record the load commands and process them all later.  */
829           if (ph->p_align % _dl_pagesize != 0)
830             LOSE (0, "ELF load command alignment not page-aligned");
831           if ((ph->p_vaddr - ph->p_offset) % ph->p_align)
832             LOSE (0, "ELF load command address/offset not properly aligned");
833           {
834             struct loadcmd *c = &loadcmds[nloadcmds++];
835             c->mapstart = ph->p_vaddr & ~(ph->p_align - 1);
836             c->mapend = ((ph->p_vaddr + ph->p_filesz + _dl_pagesize - 1)
837                          & ~(_dl_pagesize - 1));
838             c->dataend = ph->p_vaddr + ph->p_filesz;
839             c->allocend = ph->p_vaddr + ph->p_memsz;
840             c->mapoff = ph->p_offset & ~(ph->p_align - 1);
841
842             /* Optimize a common case.  */
843             if ((PF_R | PF_W | PF_X) == 7
844                 && (PROT_READ | PROT_WRITE | PROT_EXEC) == 7)
845               c->prot = _dl_pf_to_prot[ph->p_flags & (PF_R | PF_W | PF_X)];
846             else
847               {
848                 c->prot = 0;
849                 if (ph->p_flags & PF_R)
850                   c->prot |= PROT_READ;
851                 if (ph->p_flags & PF_W)
852                   c->prot |= PROT_WRITE;
853                 if (ph->p_flags & PF_X)
854                   c->prot |= PROT_EXEC;
855               }
856             break;
857           }
858         }
859
860     /* Now process the load commands and map segments into memory.  */
861     c = loadcmds;
862
863     /* Length of the sections to be loaded.  */
864     maplength = loadcmds[nloadcmds - 1].allocend - c->mapstart;
865
866     if (type == ET_DYN || type == ET_REL)
867       {
868         /* This is a position-independent shared object.  We can let the
869            kernel map it anywhere it likes, but we must have space for all
870            the segments in their specified positions relative to the first.
871            So we map the first segment without MAP_FIXED, but with its
872            extent increased to cover all the segments.  Then we remove
873            access from excess portion, and there is known sufficient space
874            there to remap from the later segments.
875
876            As a refinement, sometimes we have an address that we would
877            prefer to map such objects at; but this is only a preference,
878            the OS can do whatever it likes. */
879         caddr_t mapat;
880         ElfW(Addr) mappref;
881         mappref = (ELF_PREFERRED_ADDRESS (loader, maplength, c->mapstart)
882                    - MAP_BASE_ADDR (l));
883         mapat = map_segment (mappref, maplength, c->prot, 0, c->mapoff);
884         l->l_addr = (ElfW(Addr)) mapat - c->mapstart;
885
886         /* Change protection on the excess portion to disallow all access;
887            the portions we do not remap later will be inaccessible as if
888            unallocated.  Then jump into the normal segment-mapping loop to
889            handle the portion of the segment past the end of the file
890            mapping.  */
891         __mprotect ((caddr_t) (l->l_addr + c->mapend),
892                     loadcmds[nloadcmds - 1].allocend - c->mapend,
893                     0);
894
895         /* Remember which part of the address space this object uses.  */
896         l->l_map_start = c->mapstart + l->l_addr;
897         l->l_map_end = l->l_map_start + maplength;
898
899         goto postmap;
900       }
901     else
902       {
903         /* Notify ELF_PREFERRED_ADDRESS that we have to load this one
904            fixed.  */
905         ELF_FIXED_ADDRESS (loader, c->mapstart);
906       }
907
908     /* Remember which part of the address space this object uses.  */
909     l->l_map_start = c->mapstart + l->l_addr;
910     l->l_map_end = l->l_map_start + maplength;
911
912     while (c < &loadcmds[nloadcmds])
913       {
914         if (c->mapend > c->mapstart)
915           /* Map the segment contents from the file.  */
916           map_segment (l->l_addr + c->mapstart, c->mapend - c->mapstart,
917                        c->prot, MAP_FIXED, c->mapoff);
918
919       postmap:
920         if (l->l_phdr == 0
921             && c->mapoff <= header->e_phoff
922             && (c->mapend - c->mapstart + c->mapoff
923                 >= header->e_phoff + header->e_phnum * sizeof (ElfW(Phdr))))
924           /* Found the program header in this segment.  */
925           l->l_phdr = (void *) (c->mapstart + header->e_phoff - c->mapoff);
926
927         if (c->allocend > c->dataend)
928           {
929             /* Extra zero pages should appear at the end of this segment,
930                after the data mapped from the file.   */
931             ElfW(Addr) zero, zeroend, zeropage;
932
933             zero = l->l_addr + c->dataend;
934             zeroend = l->l_addr + c->allocend;
935             zeropage = (zero + _dl_pagesize - 1) & ~(_dl_pagesize - 1);
936
937             if (zeroend < zeropage)
938               /* All the extra data is in the last page of the segment.
939                  We can just zero it.  */
940               zeropage = zeroend;
941
942             if (zeropage > zero)
943               {
944                 /* Zero the final part of the last page of the segment.  */
945                 if ((c->prot & PROT_WRITE) == 0)
946                   {
947                     /* Dag nab it.  */
948                     if (__mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
949                                     _dl_pagesize, c->prot|PROT_WRITE) < 0)
950                       LOSE (errno, "cannot change memory protections");
951                   }
952                 memset ((void *) zero, 0, zeropage - zero);
953                 if ((c->prot & PROT_WRITE) == 0)
954                   __mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
955                               _dl_pagesize, c->prot);
956               }
957
958             if (zeroend > zeropage)
959               {
960                 /* Map the remaining zero pages in from the zero fill FD.  */
961                 caddr_t mapat;
962                 mapat = __mmap ((caddr_t) zeropage, zeroend - zeropage,
963                                 c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
964                                 ANONFD, 0);
965                 if (mapat == MAP_FAILED)
966                   LOSE (errno, "cannot map zero-fill pages");
967               }
968           }
969
970         ++c;
971       }
972
973     if (l->l_phdr == NULL)
974       {
975         /* The program header is not contained in any of the segmenst.
976            We have to allocate memory ourself and copy it over from
977            out temporary place.  */
978         ElfW(Phdr) *newp = (ElfW(Phdr) *) malloc (header->e_phnum
979                                                   * sizeof (ElfW(Phdr)));
980         if (newp == NULL)
981           LOSE (ENOMEM, "cannot allocate memory for program header");
982
983         l->l_phdr = memcpy (newp, phdr,
984                             (header->e_phnum * sizeof (ElfW(Phdr))));
985         l->l_phdr_allocated = 1;
986       }
987     else
988       /* Adjust the PT_PHDR value by the runtime load address.  */
989       (ElfW(Addr)) l->l_phdr += l->l_addr;
990   }
991
992   /* We are done mapping in the file.  We no longer need the descriptor.  */
993   __close (fd);
994
995   if (l->l_type == lt_library && type == ET_EXEC)
996     l->l_type = lt_executable;
997
998   if (l->l_ld == 0)
999     {
1000       if (type == ET_DYN)
1001         LOSE (0, "object file has no dynamic section");
1002     }
1003   else
1004     (ElfW(Addr)) l->l_ld += l->l_addr;
1005
1006   l->l_entry += l->l_addr;
1007
1008   if (_dl_debug_files)
1009     {
1010       const size_t nibbles = sizeof (void *) * 2;
1011       char buf1[nibbles + 1];
1012       char buf2[nibbles + 1];
1013       char buf3[nibbles + 1];
1014
1015       buf1[nibbles] = '\0';
1016       buf2[nibbles] = '\0';
1017       buf3[nibbles] = '\0';
1018
1019       memset (buf1, '0', nibbles);
1020       memset (buf2, '0', nibbles);
1021       memset (buf3, '0', nibbles);
1022       _itoa_word ((unsigned long int) l->l_ld, &buf1[nibbles], 16, 0);
1023       _itoa_word ((unsigned long int) l->l_addr, &buf2[nibbles], 16, 0);
1024       _itoa_word (maplength, &buf3[nibbles], 16, 0);
1025
1026       _dl_debug_message (1, "  dynamic: 0x", buf1, "  base: 0x", buf2,
1027                          "   size: 0x", buf3, "\n", NULL);
1028       memset (buf1, '0', nibbles);
1029       memset (buf2, '0', nibbles);
1030       memset (buf3, ' ', nibbles);
1031       _itoa_word ((unsigned long int) l->l_entry, &buf1[nibbles], 16, 0);
1032       _itoa_word ((unsigned long int) l->l_phdr, &buf2[nibbles], 16, 0);
1033       _itoa_word (l->l_phnum, &buf3[nibbles], 10, 0);
1034       _dl_debug_message (1, "    entry: 0x", buf1, "  phdr: 0x", buf2,
1035                          "  phnum:   ", buf3, "\n\n", NULL);
1036     }
1037
1038   elf_get_dynamic_info (l->l_ld, l->l_addr, l->l_info);
1039   if (l->l_info[DT_HASH])
1040     _dl_setup_hash (l);
1041
1042   /* If this object has DT_SYMBOLIC set modify now its scope.  We don't
1043      have to do this for the main map.  */
1044   if (l->l_info[DT_SYMBOLIC] && &l->l_searchlist != l->l_scope[0])
1045     {
1046       /* Create an appropriate searchlist.  It contains only this map.
1047
1048          XXX This is the definition of DT_SYMBOLIC in SysVr4.  The old
1049          GNU ld.so implementation had a different interpretation which
1050          is more reasonable.  We are prepared to add this possibility
1051          back as part of a GNU extension of the ELF format.  */
1052       l->l_symbolic_searchlist.r_list =
1053         (struct link_map **) malloc (sizeof (struct link_map *));
1054
1055       if (l->l_symbolic_searchlist.r_list == NULL)
1056         LOSE (ENOMEM, "cannot create searchlist");
1057
1058       l->l_symbolic_searchlist.r_list[0] = l;
1059       l->l_symbolic_searchlist.r_nlist = 1;
1060       l->l_symbolic_searchlist.r_duplist = l->l_symbolic_searchlist.r_list;
1061       l->l_symbolic_searchlist.r_nduplist = 1;
1062
1063       /* Now move the existing entries one back.  */
1064       memmove (&l->l_scope[1], &l->l_scope[0],
1065                sizeof (l->l_scope) - sizeof (l->l_scope[0]));
1066
1067       /* Now add the new entry.  */
1068       l->l_scope[0] = &l->l_symbolic_searchlist;
1069     }
1070
1071   /* Finally the file information.  */
1072   l->l_dev = st.st_dev;
1073   l->l_ino = st.st_ino;
1074
1075   return l;
1076 }
1077 \f
1078 /* Print search path.  */
1079 static void
1080 print_search_path (struct r_search_path_elem **list,
1081                    const char *what, const char *name)
1082 {
1083   char buf[max_dirnamelen + max_capstrlen];
1084   int first = 1;
1085
1086   _dl_debug_message (1, " search path=", NULL);
1087
1088   while (*list != NULL && (*list)->what == what) /* Yes, ==.  */
1089     {
1090       char *endp = __mempcpy (buf, (*list)->dirname, (*list)->dirnamelen);
1091       size_t cnt;
1092
1093       for (cnt = 0; cnt < ncapstr; ++cnt)
1094         if ((*list)->status[cnt] != nonexisting)
1095           {
1096             char *cp = __mempcpy (endp, capstr[cnt].str, capstr[cnt].len);
1097             if (cp == buf || (cp == buf + 1 && buf[0] == '/'))
1098               cp[0] = '\0';
1099             else
1100               cp[-1] = '\0';
1101             _dl_debug_message (0, first ? "" : ":", buf, NULL);
1102             first = 0;
1103           }
1104
1105       ++list;
1106     }
1107
1108   if (name != NULL)
1109     _dl_debug_message (0, "\t\t(", what, " from file ",
1110                         name[0] ? name : _dl_argv[0], ")\n", NULL);
1111   else
1112     _dl_debug_message (0, "\t\t(", what, ")\n", NULL);
1113 }
1114 \f
1115 /* Try to open NAME in one of the directories in DIRS.
1116    Return the fd, or -1.  If successful, fill in *REALNAME
1117    with the malloc'd full directory name.  */
1118
1119 static int
1120 open_path (const char *name, size_t namelen, int preloaded,
1121            struct r_search_path_elem **dirs,
1122            char **realname)
1123 {
1124   char *buf;
1125   int fd = -1;
1126   const char *current_what = NULL;
1127
1128   if (dirs == NULL || *dirs == NULL)
1129     {
1130       __set_errno (ENOENT);
1131       return -1;
1132     }
1133
1134   buf = alloca (max_dirnamelen + max_capstrlen + namelen);
1135   do
1136     {
1137       struct r_search_path_elem *this_dir = *dirs;
1138       size_t buflen = 0;
1139       size_t cnt;
1140       char *edp;
1141
1142       /* If we are debugging the search for libraries print the path
1143          now if it hasn't happened now.  */
1144       if (_dl_debug_libs && current_what != this_dir->what)
1145         {
1146           current_what = this_dir->what;
1147           print_search_path (dirs, current_what, this_dir->where);
1148         }
1149
1150       edp = (char *) __mempcpy (buf, this_dir->dirname, this_dir->dirnamelen);
1151       for (cnt = 0; fd == -1 && cnt < ncapstr; ++cnt)
1152         {
1153           /* Skip this directory if we know it does not exist.  */
1154           if (this_dir->status[cnt] == nonexisting)
1155             continue;
1156
1157           buflen =
1158             ((char *) __mempcpy (__mempcpy (edp,
1159                                             capstr[cnt].str, capstr[cnt].len),
1160                                  name, namelen)
1161              - buf);
1162
1163           /* Print name we try if this is wanted.  */
1164           if (_dl_debug_libs)
1165             _dl_debug_message (1, "  trying file=", buf, "\n", NULL);
1166
1167           fd = __open (buf, O_RDONLY);
1168           if (this_dir->status[cnt] == unknown)
1169             {
1170               if (fd != -1)
1171                 this_dir->status[cnt] = existing;
1172               else
1173                 {
1174                   /* We failed to open machine dependent library.  Let's
1175                      test whether there is any directory at all.  */
1176                   struct stat st;
1177
1178                   buf[buflen - namelen - 1] = '\0';
1179
1180                   if (__xstat (_STAT_VER, buf, &st) != 0
1181                       || ! S_ISDIR (st.st_mode))
1182                     /* The directory does not exist or it is no directory.  */
1183                     this_dir->status[cnt] = nonexisting;
1184                   else
1185                     this_dir->status[cnt] = existing;
1186                 }
1187             }
1188
1189           if (fd != -1 && preloaded && __libc_enable_secure)
1190             {
1191               /* This is an extra security effort to make sure nobody can
1192                  preload broken shared objects which are in the trusted
1193                  directories and so exploit the bugs.  */
1194               struct stat st;
1195
1196               if (__fxstat (_STAT_VER, fd, &st) != 0
1197                   || (st.st_mode & S_ISUID) == 0)
1198                 {
1199                   /* The shared object cannot be tested for being SUID
1200                      or this bit is not set.  In this case we must not
1201                      use this object.  */
1202                   __close (fd);
1203                   fd = -1;
1204                   /* We simply ignore the file, signal this by setting
1205                      the error value which would have been set by `open'.  */
1206                   errno = ENOENT;
1207                 }
1208             }
1209         }
1210
1211       if (fd != -1)
1212         {
1213           *realname = malloc (buflen);
1214           if (*realname != NULL)
1215             {
1216               memcpy (*realname, buf, buflen);
1217               return fd;
1218             }
1219           else
1220             {
1221               /* No memory for the name, we certainly won't be able
1222                  to load and link it.  */
1223               __close (fd);
1224               return -1;
1225             }
1226         }
1227       if (errno != ENOENT && errno != EACCES)
1228         /* The file exists and is readable, but something went wrong.  */
1229         return -1;
1230     }
1231   while (*++dirs != NULL);
1232
1233   return -1;
1234 }
1235
1236 /* Map in the shared object file NAME.  */
1237
1238 struct link_map *
1239 internal_function
1240 _dl_map_object (struct link_map *loader, const char *name, int preloaded,
1241                 int type, int trace_mode)
1242 {
1243   int fd;
1244   char *realname;
1245   char *name_copy;
1246   struct link_map *l;
1247
1248   /* Look for this name among those already loaded.  */
1249   for (l = _dl_loaded; l; l = l->l_next)
1250     {
1251       /* If the requested name matches the soname of a loaded object,
1252          use that object.  Elide this check for names that have not
1253          yet been opened.  */
1254       if (l->l_opencount <= 0)
1255         continue;
1256       if (!_dl_name_match_p (name, l))
1257         {
1258           const char *soname;
1259
1260           if (l->l_info[DT_SONAME] == NULL)
1261             continue;
1262
1263           soname = (const void *) (l->l_info[DT_STRTAB]->d_un.d_ptr
1264                                    + l->l_info[DT_SONAME]->d_un.d_val);
1265           if (strcmp (name, soname) != 0)
1266             continue;
1267
1268           /* We have a match on a new name -- cache it.  */
1269           add_name_to_object (l, soname);
1270         }
1271
1272       /* We have a match -- bump the reference count and return it.  */
1273       ++l->l_opencount;
1274       return l;
1275     }
1276
1277   /* Display information if we are debugging.  */
1278   if (_dl_debug_files && loader != NULL)
1279     _dl_debug_message (1, "\nfile=", name, ";  needed by ",
1280                        loader->l_name[0] ? loader->l_name : _dl_argv[0],
1281                        "\n", NULL);
1282
1283   if (strchr (name, '/') == NULL)
1284     {
1285       /* Search for NAME in several places.  */
1286
1287       size_t namelen = strlen (name) + 1;
1288
1289       if (_dl_debug_libs)
1290         _dl_debug_message (1, "find library=", name, "; searching\n", NULL);
1291
1292       fd = -1;
1293
1294       /* First try the DT_RPATH of the dependent object that caused NAME
1295          to be loaded.  Then that object's dependent, and on up.  */
1296       for (l = loader; fd == -1 && l; l = l->l_loader)
1297         if (l->l_info[DT_RPATH])
1298           {
1299             /* Make sure the cache information is available.  */
1300             if (l->l_rpath_dirs == NULL)
1301               {
1302                 size_t ptrval = (l->l_info[DT_STRTAB]->d_un.d_ptr
1303                                  + l->l_info[DT_RPATH]->d_un.d_val);
1304                 l->l_rpath_dirs =
1305                   decompose_rpath ((const char *) ptrval, l);
1306               }
1307
1308             if (l->l_rpath_dirs != NULL)
1309               fd = open_path (name, namelen, preloaded, l->l_rpath_dirs,
1310                               &realname);
1311           }
1312
1313       /* If dynamically linked, try the DT_RPATH of the executable itself.  */
1314       l = _dl_loaded;
1315       if (fd == -1 && l && l->l_type != lt_loaded && l != loader
1316           && l->l_rpath_dirs != NULL)
1317         fd = open_path (name, namelen, preloaded, l->l_rpath_dirs, &realname);
1318
1319       /* Try the LD_LIBRARY_PATH environment variable.  */
1320       if (fd == -1 && env_path_list != NULL)
1321         fd = open_path (name, namelen, preloaded, env_path_list, &realname);
1322
1323       if (fd == -1)
1324         {
1325           /* Check the list of libraries in the file /etc/ld.so.cache,
1326              for compatibility with Linux's ldconfig program.  */
1327           extern const char *_dl_load_cache_lookup (const char *name);
1328           const char *cached = _dl_load_cache_lookup (name);
1329           if (cached)
1330             {
1331               fd = __open (cached, O_RDONLY);
1332               if (fd != -1)
1333                 {
1334                   realname = local_strdup (cached);
1335                   if (realname == NULL)
1336                     {
1337                       __close (fd);
1338                       fd = -1;
1339                     }
1340                 }
1341             }
1342         }
1343
1344       /* Finally, try the default path.  */
1345       if (fd == -1)
1346         fd = open_path (name, namelen, preloaded, rtld_search_dirs, &realname);
1347
1348       /* Add another newline when we a tracing the library loading.  */
1349       if (_dl_debug_libs)
1350         _dl_debug_message (1, "\n", NULL);
1351     }
1352   else
1353     {
1354       /* The path may contain dynamic string tokens.  */
1355       realname = (loader
1356                   ? expand_dynamic_string_token (loader, name)
1357                   : local_strdup (name));
1358       if (realname == NULL)
1359         fd = -1;
1360       else
1361         {
1362           fd = __open (realname, O_RDONLY);
1363           if (fd == -1)
1364             free (realname);
1365         }
1366     }
1367
1368   if (fd == -1)
1369     {
1370       if (trace_mode)
1371         {
1372           /* We haven't found an appropriate library.  But since we
1373              are only interested in the list of libraries this isn't
1374              so severe.  Fake an entry with all the information we
1375              have.  */
1376           static const ElfW(Symndx) dummy_bucket = STN_UNDEF;
1377
1378           /* Enter the new object in the list of loaded objects.  */
1379           if ((name_copy = local_strdup (name)) == NULL
1380               || (l = _dl_new_object (name_copy, name, type, loader)) == NULL)
1381             _dl_signal_error (ENOMEM, name,
1382                               "cannot create shared object descriptor");
1383           /* We use an opencount of 0 as a sign for the faked entry.
1384              Since the descriptor is initialized with zero we do not
1385              have do this here.
1386           l->l_opencount = 0;
1387           l->l_reserved = 0; */
1388           l->l_buckets = &dummy_bucket;
1389           l->l_nbuckets = 1;
1390           l->l_relocated = 1;
1391
1392           return l;
1393         }
1394       else
1395         _dl_signal_error (errno, name, "cannot open shared object file");
1396     }
1397
1398   return _dl_map_object_from_fd (name, fd, realname, loader, type);
1399 }