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