(dl_open_worker): Pass __RTLD_AUDIT flag from caller to _dl_map_object_deps.
[kopensolaris-gnu/glibc.git] / elf / dl-open.c
1 /* Load a shared object at runtime, relocate it, and run its initializer.
2    Copyright (C) 1996-2004, 2005 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 <assert.h>
21 #include <dlfcn.h>
22 #include <errno.h>
23 #include <libintl.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <sys/mman.h>           /* Check whether MAP_COPY is defined.  */
29 #include <sys/param.h>
30 #include <bits/libc-lock.h>
31 #include <ldsodefs.h>
32 #include <bp-sym.h>
33 #include <caller.h>
34
35 #include <dl-dst.h>
36
37
38 #ifndef SHARED
39 /* Giving this initialized value preallocates some surplus bytes in the
40    static TLS area, see __libc_setup_tls (libc-tls.c).  */
41 size_t _dl_tls_static_size = 2048;
42 #endif
43
44 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
45                                     void (*dl_main) (const ElfW(Phdr) *phdr,
46                                                      ElfW(Word) phnum,
47                                                      ElfW(Addr) *user_entry));
48 weak_extern (BP_SYM (_dl_sysdep_start))
49
50 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
51
52 /* Undefine the following for debugging.  */
53 /* #define SCOPE_DEBUG 1 */
54 #ifdef SCOPE_DEBUG
55 static void show_scope (struct link_map *new);
56 #endif
57
58 /* We must be carefull not to leave us in an inconsistent state.  Thus we
59    catch any error and re-raise it after cleaning up.  */
60
61 struct dl_open_args
62 {
63   const char *file;
64   int mode;
65   /* This is the caller of the dlopen() function.  */
66   const void *caller_dlopen;
67   /* This is the caller if _dl_open().  */
68   const void *caller_dl_open;
69   struct link_map *map;
70   /* Namespace ID.  */
71   Lmid_t nsid;
72   /* Original parameters to the program and the current environment.  */
73   int argc;
74   char **argv;
75   char **env;
76 };
77
78
79 static int
80 add_to_global (struct link_map *new)
81 {
82   struct link_map **new_global;
83   unsigned int to_add = 0;
84   unsigned int cnt;
85
86   /* Count the objects we have to put in the global scope.  */
87   for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
88     if (new->l_searchlist.r_list[cnt]->l_global == 0)
89       ++to_add;
90
91   /* The symbols of the new objects and its dependencies are to be
92      introduced into the global scope that will be used to resolve
93      references from other dynamically-loaded objects.
94
95      The global scope is the searchlist in the main link map.  We
96      extend this list if necessary.  There is one problem though:
97      since this structure was allocated very early (before the libc
98      is loaded) the memory it uses is allocated by the malloc()-stub
99      in the ld.so.  When we come here these functions are not used
100      anymore.  Instead the malloc() implementation of the libc is
101      used.  But this means the block from the main map cannot be used
102      in an realloc() call.  Therefore we allocate a completely new
103      array the first time we have to add something to the locale scope.  */
104
105   if (GL(dl_ns)[new->l_ns]._ns_global_scope_alloc == 0)
106     {
107       /* This is the first dynamic object given global scope.  */
108       GL(dl_ns)[new->l_ns]._ns_global_scope_alloc
109         = GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist + to_add + 8;
110       new_global = (struct link_map **)
111         malloc (GL(dl_ns)[new->l_ns]._ns_global_scope_alloc
112                 * sizeof (struct link_map *));
113       if (new_global == NULL)
114         {
115           GL(dl_ns)[new->l_ns]._ns_global_scope_alloc = 0;
116         nomem:
117           _dl_signal_error (ENOMEM, new->l_libname->name, NULL,
118                             N_("cannot extend global scope"));
119           return 1;
120         }
121
122       /* Copy over the old entries.  */
123       GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list
124         = memcpy (new_global,
125                   GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list,
126                   (GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist
127                    * sizeof (struct link_map *)));
128     }
129   else if (GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist + to_add
130            > GL(dl_ns)[new->l_ns]._ns_global_scope_alloc)
131     {
132       /* We have to extend the existing array of link maps in the
133          main map.  */
134       new_global = (struct link_map **)
135         realloc (GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list,
136                  ((GL(dl_ns)[new->l_ns]._ns_global_scope_alloc + to_add + 8)
137                   * sizeof (struct link_map *)));
138       if (new_global == NULL)
139         goto nomem;
140
141       GL(dl_ns)[new->l_ns]._ns_global_scope_alloc += to_add + 8;
142       GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list = new_global;
143     }
144
145   /* Now add the new entries.  */
146   for (cnt = 0; cnt < new->l_searchlist.r_nlist; ++cnt)
147     {
148       struct link_map *map = new->l_searchlist.r_list[cnt];
149
150       if (map->l_global == 0)
151         {
152           map->l_global = 1;
153           GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_list[GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist]
154             = map;
155           ++GL(dl_ns)[new->l_ns]._ns_main_searchlist->r_nlist;
156         }
157     }
158
159   return 0;
160 }
161
162
163 static void
164 dl_open_worker (void *a)
165 {
166   struct dl_open_args *args = a;
167   const char *file = args->file;
168   int mode = args->mode;
169   struct link_map *new, *l;
170   int lazy;
171   unsigned int i;
172 #ifdef USE_TLS
173   bool any_tls = false;
174 #endif
175   struct link_map *call_map = NULL;
176
177   /* Check whether _dl_open() has been called from a valid DSO.  */
178   if (__check_caller (args->caller_dl_open,
179                       allow_libc|allow_libdl|allow_ldso) != 0)
180     _dl_signal_error (0, "dlopen", NULL, N_("invalid caller"));
181
182   /* Determine the caller's map if necessary.  This is needed in case
183      we have a DST, when we don't know the namespace ID we have to put
184      the new object in, or when the file name has no path in which
185      case we need to look along the RUNPATH/RPATH of the caller.  */
186   const char *dst = strchr (file, '$');
187   if (dst != NULL || args->nsid == __LM_ID_CALLER
188       || strchr (file, '/') == NULL)
189     {
190       const void *caller_dlopen = args->caller_dlopen;
191
192       /* We have to find out from which object the caller is calling.
193          By default we assume this is the main application.  */
194       call_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
195
196       for (Lmid_t ns = 0; ns < DL_NNS; ++ns)
197         for (l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
198           if (caller_dlopen >= (const void *) l->l_map_start
199               && caller_dlopen < (const void *) l->l_map_end)
200             {
201               /* There must be exactly one DSO for the range of the virtual
202                  memory.  Otherwise something is really broken.  */
203               assert (ns == l->l_ns);
204               call_map = l;
205               goto found_caller;
206             }
207
208     found_caller:
209       if (args->nsid == __LM_ID_CALLER)
210         {
211 #ifndef SHARED
212           /* In statically linked apps there might be no loaded object.  */
213           if (call_map == NULL)
214             args->nsid = LM_ID_BASE;
215           else
216 #endif
217             args->nsid = call_map->l_ns;
218         }
219     }
220
221   assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
222
223   /* Maybe we have to expand a DST.  */
224   if (__builtin_expect (dst != NULL, 0))
225     {
226       size_t len = strlen (file);
227       size_t required;
228       char *new_file;
229
230       /* DSTs must not appear in SUID/SGID programs.  */
231       if (INTUSE(__libc_enable_secure))
232         /* This is an error.  */
233         _dl_signal_error (0, "dlopen", NULL,
234                           N_("DST not allowed in SUID/SGID programs"));
235
236
237       /* Determine how much space we need.  We have to allocate the
238          memory locally.  */
239       required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));
240
241       /* Get space for the new file name.  */
242       new_file = (char *) alloca (required + 1);
243
244       /* Generate the new file name.  */
245       _dl_dst_substitute (call_map, file, new_file, 0);
246
247       /* If the substitution failed don't try to load.  */
248       if (*new_file == '\0')
249         _dl_signal_error (0, "dlopen", NULL,
250                           N_("empty dynamic string token substitution"));
251
252       /* Now we have a new file name.  */
253       file = new_file;
254
255       /* It does not matter whether call_map is set even if we
256          computed it only because of the DST.  Since the path contains
257          a slash the value is not used.  See dl-load.c.  */
258     }
259
260   /* Load the named object.  */
261   args->map = new = _dl_map_object (call_map, file, 0, lt_loaded, 0,
262                                     mode | __RTLD_CALLMAP, args->nsid);
263
264   /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
265      set and the object is not already loaded.  */
266   if (new == NULL)
267     {
268       assert (mode & RTLD_NOLOAD);
269       return;
270     }
271
272   if (__builtin_expect (mode & __RTLD_SPROF, 0))
273     /* This happens only if we load a DSO for 'sprof'.  */
274     return;
275
276   /* This object is directly loaded.  */
277   ++new->l_direct_opencount;
278
279   /* It was already open.  */
280   if (__builtin_expect (new->l_searchlist.r_list != NULL, 0))
281     {
282       /* Let the user know about the opencount.  */
283       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
284         _dl_debug_printf ("opening file=%s [%lu]; opencount=%u\n\n",
285                           new->l_name, new->l_ns, new->l_opencount);
286
287       /* If the user requested the object to be in the global namespace
288          but it is not so far, add it now.  */
289       if ((mode & RTLD_GLOBAL) && new->l_global == 0)
290         (void) add_to_global (new);
291
292       if (new->l_direct_opencount == 1)
293         /* This is the only direct reference.  Increment all the
294            dependencies' reference counter.  */
295         for (i = 0; i < new->l_searchlist.r_nlist; ++i)
296           ++new->l_searchlist.r_list[i]->l_opencount;
297       else
298         /* Increment just the reference counter of the object.  */
299         ++new->l_opencount;
300
301       assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
302
303       return;
304     }
305
306   /* Load that object's dependencies.  */
307   _dl_map_object_deps (new, NULL, 0, 0,
308                        mode & (__RTLD_DLOPEN | RTLD_DEEPBIND | __RTLD_AUDIT));
309
310   /* So far, so good.  Now check the versions.  */
311   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
312     if (new->l_searchlist.r_list[i]->l_real->l_versions == NULL)
313       (void) _dl_check_map_versions (new->l_searchlist.r_list[i]->l_real,
314                                      0, 0);
315
316 #ifdef SCOPE_DEBUG
317   show_scope (new);
318 #endif
319
320 #ifdef SHARED
321   /* Auditing checkpoint: we have added all objects.  */
322   if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
323     {
324       struct link_map *head = GL(dl_ns)[new->l_ns]._ns_loaded;
325       /* Do not call the functions for any auditing object.  */
326       if (head->l_auditing == 0)
327         {
328           struct audit_ifaces *afct = GLRO(dl_audit);
329           for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
330             {
331               if (afct->activity != NULL)
332                 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
333
334               afct = afct->next;
335             }
336         }
337     }
338 #endif
339
340   /* Notify the debugger all new objects are now ready to go.  */
341   struct r_debug *r = _dl_debug_initialize (0, args->nsid);
342   r->r_state = RT_CONSISTENT;
343   _dl_debug_state ();
344
345   /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */
346   lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && GLRO(dl_lazy);
347
348   /* Relocate the objects loaded.  We do this in reverse order so that copy
349      relocs of earlier objects overwrite the data written by later objects.  */
350
351   l = new;
352   while (l->l_next)
353     l = l->l_next;
354   while (1)
355     {
356       if (! l->l_real->l_relocated)
357         {
358 #ifdef SHARED
359           if (GLRO(dl_profile) != NULL)
360             {
361               /* If this here is the shared object which we want to profile
362                  make sure the profile is started.  We can find out whether
363                  this is necessary or not by observing the `_dl_profile_map'
364                  variable.  If was NULL but is not NULL afterwars we must
365                  start the profiling.  */
366               struct link_map *old_profile_map = GL(dl_profile_map);
367
368               _dl_relocate_object (l, l->l_scope, 1, 1);
369
370               if (old_profile_map == NULL && GL(dl_profile_map) != NULL)
371                 {
372                   /* We must prepare the profiling.  */
373                   _dl_start_profile ();
374
375                   /* Prevent unloading the object.  */
376                   GL(dl_profile_map)->l_flags_1 |= DF_1_NODELETE;
377                 }
378             }
379           else
380 #endif
381             _dl_relocate_object (l, l->l_scope, lazy, 0);
382         }
383
384       if (l == new)
385         break;
386       l = l->l_prev;
387     }
388
389   /* Increment the open count for all dependencies.  If the file is
390      not loaded as a dependency here add the search list of the newly
391      loaded object to the scope.  */
392   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
393     if (++new->l_searchlist.r_list[i]->l_opencount > 1
394         && new->l_real->l_searchlist.r_list[i]->l_type == lt_loaded)
395       {
396         struct link_map *imap = new->l_searchlist.r_list[i];
397         struct r_scope_elem **runp = imap->l_scope;
398         size_t cnt = 0;
399
400         while (*runp != NULL)
401           {
402             /* This can happen if imap was just loaded, but during
403                relocation had l_opencount bumped because of relocation
404                dependency.  Avoid duplicates in l_scope.  */
405             if (__builtin_expect (*runp == &new->l_searchlist, 0))
406               break;
407
408             ++cnt;
409             ++runp;
410           }
411
412         if (*runp != NULL)
413           /* Avoid duplicates.  */
414           continue;
415
416         if (__builtin_expect (cnt + 1 >= imap->l_scope_max, 0))
417           {
418             /* The 'r_scope' array is too small.  Allocate a new one
419                dynamically.  */
420             struct r_scope_elem **newp;
421             size_t new_size = imap->l_scope_max * 2;
422
423             if (imap->l_scope == imap->l_scope_mem)
424               {
425                 newp = (struct r_scope_elem **)
426                   malloc (new_size * sizeof (struct r_scope_elem *));
427                 if (newp == NULL)
428                   _dl_signal_error (ENOMEM, "dlopen", NULL,
429                                     N_("cannot create scope list"));
430                 imap->l_scope = memcpy (newp, imap->l_scope,
431                                         cnt * sizeof (imap->l_scope[0]));
432               }
433             else
434               {
435                 newp = (struct r_scope_elem **)
436                   realloc (imap->l_scope,
437                            new_size * sizeof (struct r_scope_elem *));
438                 if (newp == NULL)
439                   _dl_signal_error (ENOMEM, "dlopen", NULL,
440                                     N_("cannot create scope list"));
441                 imap->l_scope = newp;
442               }
443
444             imap->l_scope_max = new_size;
445           }
446
447         imap->l_scope[cnt++] = &new->l_searchlist;
448         imap->l_scope[cnt] = NULL;
449       }
450 #if USE_TLS
451     else if (new->l_searchlist.r_list[i]->l_opencount == 1
452              /* Only if the module defines thread local data.  */
453              && __builtin_expect (new->l_searchlist.r_list[i]->l_tls_blocksize
454                                   > 0, 0))
455       {
456         /* Now that we know the object is loaded successfully add
457            modules containing TLS data to the slot info table.  We
458            might have to increase its size.  */
459         _dl_add_to_slotinfo (new->l_searchlist.r_list[i]);
460
461         if (new->l_searchlist.r_list[i]->l_need_tls_init)
462           {
463             new->l_searchlist.r_list[i]->l_need_tls_init = 0;
464 # ifdef SHARED
465             /* Update the slot information data for at least the
466                generation of the DSO we are allocating data for.  */
467             _dl_update_slotinfo (new->l_searchlist.r_list[i]->l_tls_modid);
468 # endif
469
470             GL(dl_init_static_tls) (new->l_searchlist.r_list[i]);
471             assert (new->l_searchlist.r_list[i]->l_need_tls_init == 0);
472           }
473
474         /* We have to bump the generation counter.  */
475         any_tls = true;
476       }
477
478   /* Bump the generation number if necessary.  */
479   if (any_tls && __builtin_expect (++GL(dl_tls_generation) == 0, 0))
480     _dl_fatal_printf (N_("\
481 TLS generation counter wrapped!  Please report this."));
482 #endif
483
484   /* Run the initializer functions of new objects.  */
485   _dl_init (new, args->argc, args->argv, args->env);
486
487   /* Now we can make the new map available in the global scope.  */
488   if (mode & RTLD_GLOBAL)
489     /* Move the object in the global namespace.  */
490     if (add_to_global (new) != 0)
491       /* It failed.  */
492       return;
493
494   /* Mark the object as not deletable if the RTLD_NODELETE flags was
495      passed.  */
496   if (__builtin_expect (mode & RTLD_NODELETE, 0))
497     new->l_flags_1 |= DF_1_NODELETE;
498
499 #ifndef SHARED
500   /* We must be the static _dl_open in libc.a.  A static program that
501      has loaded a dynamic object now has competition.  */
502   __libc_multiple_libcs = 1;
503 #endif
504
505   /* Let the user know about the opencount.  */
506   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
507     _dl_debug_printf ("opening file=%s [%lu]; opencount=%u\n\n",
508                       new->l_name, new->l_ns, new->l_opencount);
509 }
510
511
512 void *
513 _dl_open (const char *file, int mode, const void *caller_dlopen, Lmid_t nsid,
514           int argc, char *argv[], char *env[])
515 {
516   struct dl_open_args args;
517   const char *objname;
518   const char *errstring;
519   int errcode;
520
521   if ((mode & RTLD_BINDING_MASK) == 0)
522     /* One of the flags must be set.  */
523     _dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()"));
524
525   /* Make sure we are alone.  */
526   __rtld_lock_lock_recursive (GL(dl_load_lock));
527
528   if (nsid == LM_ID_NEWLM)
529     {
530       /* Find a new namespace.  */
531       for (nsid = 1; nsid < DL_NNS; ++nsid)
532         if (GL(dl_ns)[nsid]._ns_loaded == NULL)
533           break;
534
535       if (nsid == DL_NNS)
536         {
537           /* No more namespace available.  */
538           __rtld_lock_unlock_recursive (GL(dl_load_lock));
539
540           _dl_signal_error (EINVAL, file, NULL, N_("\
541 no more namespaces available for dlmopen()"));
542         }
543
544       _dl_debug_initialize (0, nsid)->r_state = RT_CONSISTENT;
545     }
546   /* Never allow loading a DSO in a namespace which is empty.  Such
547      direct placements is only causing problems.  Also don't allow
548      loading into a namespace used for auditing.  */
549   else if (nsid != LM_ID_BASE && nsid != __LM_ID_CALLER
550            && (GL(dl_ns)[nsid]._ns_nloaded == 0
551                || GL(dl_ns)[nsid]._ns_loaded->l_auditing))
552     _dl_signal_error (EINVAL, file, NULL,
553                       N_("invalid target namespace in dlmopen()"));
554
555   args.file = file;
556   args.mode = mode;
557   args.caller_dlopen = caller_dlopen;
558   args.caller_dl_open = RETURN_ADDRESS (0);
559   args.map = NULL;
560   args.nsid = nsid;
561   args.argc = argc;
562   args.argv = argv;
563   args.env = env;
564   errcode = _dl_catch_error (&objname, &errstring, dl_open_worker, &args);
565
566 #ifndef MAP_COPY
567   /* We must munmap() the cache file.  */
568   _dl_unload_cache ();
569 #endif
570
571   /* Release the lock.  */
572   __rtld_lock_unlock_recursive (GL(dl_load_lock));
573
574   if (__builtin_expect (errstring != NULL, 0))
575     {
576       /* Some error occurred during loading.  */
577       char *local_errstring;
578       size_t len_errstring;
579
580       /* Remove the object from memory.  It may be in an inconsistent
581          state if relocation failed, for example.  */
582       if (args.map)
583         {
584           /* Increment open counters for all objects since this
585              sometimes has not happened yet.  */
586           if (args.map->l_searchlist.r_list[0]->l_opencount == 0)
587             for (unsigned int i = 0; i < args.map->l_searchlist.r_nlist; ++i)
588               ++args.map->l_searchlist.r_list[i]->l_opencount;
589
590 #ifdef USE_TLS
591           /* Maybe some of the modules which were loaded use TLS.
592              Since it will be removed in the following _dl_close call
593              we have to mark the dtv array as having gaps to fill the
594              holes.  This is a pessimistic assumption which won't hurt
595              if not true.  There is no need to do this when we are
596              loading the auditing DSOs since TLS has not yet been set
597              up.  */
598           if ((mode & __RTLD_AUDIT) == 0)
599             GL(dl_tls_dtv_gaps) = true;
600 #endif
601
602           _dl_close (args.map);
603         }
604
605       /* Make a local copy of the error string so that we can release the
606          memory allocated for it.  */
607       len_errstring = strlen (errstring) + 1;
608       if (objname == errstring + len_errstring)
609         {
610           size_t total_len = len_errstring + strlen (objname) + 1;
611           local_errstring = alloca (total_len);
612           memcpy (local_errstring, errstring, total_len);
613           objname = local_errstring + len_errstring;
614         }
615       else
616         {
617           local_errstring = alloca (len_errstring);
618           memcpy (local_errstring, errstring, len_errstring);
619         }
620
621       if (errstring != INTUSE(_dl_out_of_memory))
622         free ((char *) errstring);
623
624       assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
625
626       /* Reraise the error.  */
627       _dl_signal_error (errcode, objname, NULL, local_errstring);
628     }
629
630   assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
631
632 #ifndef SHARED
633   DL_STATIC_INIT (args.map);
634 #endif
635
636   return args.map;
637 }
638
639
640 #ifdef SCOPE_DEBUG
641 #include <unistd.h>
642
643 static void
644 show_scope (struct link_map *new)
645 {
646   int scope_cnt;
647
648   for (scope_cnt = 0; new->l_scope[scope_cnt] != NULL; ++scope_cnt)
649     {
650       char numbuf[2];
651       unsigned int cnt;
652
653       numbuf[0] = '0' + scope_cnt;
654       numbuf[1] = '\0';
655       _dl_printf ("scope %s:", numbuf);
656
657       for (cnt = 0; cnt < new->l_scope[scope_cnt]->r_nlist; ++cnt)
658         if (*new->l_scope[scope_cnt]->r_list[cnt]->l_name)
659           _dl_printf (" %s", new->l_scope[scope_cnt]->r_list[cnt]->l_name);
660         else
661           _dl_printf (" <main>");
662
663       _dl_printf ("\n");
664     }
665 }
666 #endif