elf/dl-open.c

   1 /* Load a shared object at runtime, relocate it, and run its initializer.
   2    Copyright (C) 1996-2004, 2005, 2006 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       /* Determine how much space we need.  We have to allocate the
 225          memory locally.  */
 226       required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));
 227
 228       /* Get space for the new file name.  */
 229       new_file = (char *) alloca (required + 1);
 230
 231       /* Generate the new file name.  */
 232       _dl_dst_substitute (call_map, file, new_file, 0);
 233
 234       /* If the substitution failed don't try to load.  */
 235       if (*new_file == '\0')
 236         _dl_signal_error (0, "dlopen", NULL,
 237                           N_("empty dynamic string token substitution"));
 238
 239       /* Now we have a new file name.  */
 240       file = new_file;
 241
 242       /* It does not matter whether call_map is set even if we
 243          computed it only because of the DST.  Since the path contains
 244          a slash the value is not used.  See dl-load.c.  */
 245     }
 246
 247   /* Load the named object.  */
 248   args->map = new = _dl_map_object (call_map, file, 0, lt_loaded, 0,
 249                                     mode | __RTLD_CALLMAP, args->nsid);
 250
 251   /* If the pointer returned is NULL this means the RTLD_NOLOAD flag is
 252      set and the object is not already loaded.  */
 253   if (new == NULL)
 254     {
 255       assert (mode & RTLD_NOLOAD);
 256       return;
 257     }
 258
 259   if (__builtin_expect (mode & __RTLD_SPROF, 0))
 260     /* This happens only if we load a DSO for 'sprof'.  */
 261     return;
 262
 263   /* This object is directly loaded.  */
 264   ++new->l_direct_opencount;
 265
 266   /* It was already open.  */
 267   if (__builtin_expect (new->l_searchlist.r_list != NULL, 0))
 268     {
 269       /* Let the user know about the opencount.  */
 270       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
 271         _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
 272                           new->l_name, new->l_ns, new->l_direct_opencount);
 273
 274       /* If the user requested the object to be in the global namespace
 275          but it is not so far, add it now.  */
 276       if ((mode & RTLD_GLOBAL) && new->l_global == 0)
 277         (void) add_to_global (new);
 278
 279       assert (_dl_debug_initialize (0, args->nsid)->r_state == RT_CONSISTENT);
 280
 281       return;
 282     }
 283
 284   /* Load that object's dependencies.  */
 285   _dl_map_object_deps (new, NULL, 0, 0,
 286                        mode & (__RTLD_DLOPEN | RTLD_DEEPBIND | __RTLD_AUDIT));
 287
 288   /* So far, so good.  Now check the versions.  */
 289   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
 290     if (new->l_searchlist.r_list[i]->l_real->l_versions == NULL)
 291       (void) _dl_check_map_versions (new->l_searchlist.r_list[i]->l_real,
 292                                      0, 0);
 293
 294 #ifdef SCOPE_DEBUG
 295   show_scope (new);
 296 #endif
 297
 298 #ifdef SHARED
 299   /* Auditing checkpoint: we have added all objects.  */
 300   if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
 301     {
 302       struct link_map *head = GL(dl_ns)[new->l_ns]._ns_loaded;
 303       /* Do not call the functions for any auditing object.  */
 304       if (head->l_auditing == 0)
 305         {
 306           struct audit_ifaces *afct = GLRO(dl_audit);
 307           for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
 308             {
 309               if (afct->activity != NULL)
 310                 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
 311
 312               afct = afct->next;
 313             }
 314         }
 315     }
 316 #endif
 317
 318   /* Notify the debugger all new objects are now ready to go.  */
 319   struct r_debug *r = _dl_debug_initialize (0, args->nsid);
 320   r->r_state = RT_CONSISTENT;
 321   _dl_debug_state ();
 322
 323   /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */
 324   lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && GLRO(dl_lazy);
 325
 326   /* Relocate the objects loaded.  We do this in reverse order so that copy
 327      relocs of earlier objects overwrite the data written by later objects.  */
 328
 329   l = new;
 330   while (l->l_next)
 331     l = l->l_next;
 332   while (1)
 333     {
 334       if (! l->l_real->l_relocated)
 335         {
 336 #ifdef SHARED
 337           if (__builtin_expect (GLRO(dl_profile) != NULL, 0))
 338             {
 339               /* If this here is the shared object which we want to profile
 340                  make sure the profile is started.  We can find out whether
 341                  this is necessary or not by observing the `_dl_profile_map'
 342                  variable.  If was NULL but is not NULL afterwars we must
 343                  start the profiling.  */
 344               struct link_map *old_profile_map = GL(dl_profile_map);
 345
 346               _dl_relocate_object (l, l->l_scope, 1, 1);
 347
 348               if (old_profile_map == NULL && GL(dl_profile_map) != NULL)
 349                 {
 350                   /* We must prepare the profiling.  */
 351                   _dl_start_profile ();
 352
 353                   /* Prevent unloading the object.  */
 354                   GL(dl_profile_map)->l_flags_1 |= DF_1_NODELETE;
 355                 }
 356             }
 357           else
 358 #endif
 359             _dl_relocate_object (l, l->l_scope, lazy, 0);
 360         }
 361
 362       if (l == new)
 363         break;
 364       l = l->l_prev;
 365     }
 366
 367   /* If the file is not loaded now as a dependency, add the search
 368      list of the newly loaded object to the scope.  */
 369   for (i = 0; i < new->l_searchlist.r_nlist; ++i)
 370     {
 371       struct link_map *imap = new->l_searchlist.r_list[i];
 372
 373       /* If the initializer has been called already, the object has
 374          not been loaded here and now.  */
 375       if (imap->l_init_called && imap->l_type == lt_loaded)
 376         {
 377           struct r_scope_elem **runp = imap->l_scope;
 378           size_t cnt = 0;
 379
 380           while (*runp != NULL)
 381             {
 382               ++cnt;
 383               ++runp;
 384             }
 385
 386           if (*runp != NULL)
 387             /* Avoid duplicates.  */
 388             continue;
 389
 390           if (__builtin_expect (cnt + 1 >= imap->l_scope_max, 0))
 391             {
 392               /* The 'r_scope' array is too small.  Allocate a new one
 393                  dynamically.  */
 394               struct r_scope_elem **newp;
 395               size_t new_size = imap->l_scope_max * 2;
 396
 397               if (imap->l_scope == imap->l_scope_mem)
 398                 {
 399                   newp = (struct r_scope_elem **)
 400                     malloc (new_size * sizeof (struct r_scope_elem *));
 401                   if (newp == NULL)
 402                     _dl_signal_error (ENOMEM, "dlopen", NULL,
 403                                       N_("cannot create scope list"));
 404                   imap->l_scope = memcpy (newp, imap->l_scope,
 405                                           cnt * sizeof (imap->l_scope[0]));
 406                 }
 407               else
 408                 {
 409                   newp = (struct r_scope_elem **)
 410                     realloc (imap->l_scope,
 411                              new_size * sizeof (struct r_scope_elem *));
 412                   if (newp == NULL)
 413                     _dl_signal_error (ENOMEM, "dlopen", NULL,
 414                                       N_("cannot create scope list"));
 415                   imap->l_scope = newp;
 416                 }
 417
 418               imap->l_scope_max = new_size;
 419             }
 420
 421           imap->l_scope[cnt++] = &new->l_searchlist;
 422           imap->l_scope[cnt] = NULL;
 423         }
 424 #if USE_TLS
 425       /* Only add TLS memory if this object is loaded now and
 426          therefore is not yet initialized.  */
 427       else if (! imap->l_init_called
 428                /* Only if the module defines thread local data.  */
 429                && __builtin_expect (imap->l_tls_blocksize > 0, 0))
 430         {
 431           /* Now that we know the object is loaded successfully add
 432              modules containing TLS data to the slot info table.  We
 433              might have to increase its size.  */
 434           _dl_add_to_slotinfo (imap);
 435
 436           if (imap->l_need_tls_init)
 437             {
 438               imap->l_need_tls_init = 0;
 439 # ifdef SHARED
 440               /* Update the slot information data for at least the
 441                  generation of the DSO we are allocating data for.  */
 442               _dl_update_slotinfo (imap->l_tls_modid);
 443 # endif
 444
 445               GL(dl_init_static_tls) (imap);
 446               assert (imap->l_need_tls_init == 0);
 447             }
 448
 449           /* We have to bump the generation counter.  */
 450           any_tls = true;
 451         }
 452 #endif
 453     }
 454
 455 #if USE_TLS
 456   /* Bump the generation number if necessary.  */
 457   if (any_tls && __builtin_expect (++GL(dl_tls_generation) == 0, 0))
 458     _dl_fatal_printf (N_("\
 459 TLS generation counter wrapped!  Please report this."));
 460 #endif
 461
 462   /* Run the initializer functions of new objects.  */
 463   _dl_init (new, args->argc, args->argv, args->env);
 464
 465   /* Now we can make the new map available in the global scope.  */
 466   if (mode & RTLD_GLOBAL)
 467     /* Move the object in the global namespace.  */
 468     if (add_to_global (new) != 0)
 469       /* It failed.  */
 470       return;
 471
 472   /* Mark the object as not deletable if the RTLD_NODELETE flags was
 473      passed.  */
 474   if (__builtin_expect (mode & RTLD_NODELETE, 0))
 475     new->l_flags_1 |= DF_1_NODELETE;
 476
 477 #ifndef SHARED
 478   /* We must be the static _dl_open in libc.a.  A static program that
 479      has loaded a dynamic object now has competition.  */
 480   __libc_multiple_libcs = 1;
 481 #endif
 482
 483   /* Let the user know about the opencount.  */
 484   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
 485     _dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
 486                       new->l_name, new->l_ns, new->l_direct_opencount);
 487 }
 488
 489
 490 void *
 491 _dl_open (const char *file, int mode, const void *caller_dlopen, Lmid_t nsid,
 492           int argc, char *argv[], char *env[])
 493 {
 494   if ((mode & RTLD_BINDING_MASK) == 0)
 495     /* One of the flags must be set.  */
 496     _dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()"));
 497
 498   /* Make sure we are alone.  */
 499   __rtld_lock_lock_recursive (GL(dl_load_lock));
 500
 501   if (nsid == LM_ID_NEWLM)
 502     {
 503       /* Find a new namespace.  */
 504       for (nsid = 1; nsid < DL_NNS; ++nsid)
 505         if (GL(dl_ns)[nsid]._ns_loaded == NULL)
 506           break;
 507
 508       if (nsid == DL_NNS)
 509         {
 510           /* No more namespace available.  */
 511           __rtld_lock_unlock_recursive (GL(dl_load_lock));
 512
 513           _dl_signal_error (EINVAL, file, NULL, N_("\
 514 no more namespaces available for dlmopen()"));
 515         }
 516
 517       _dl_debug_initialize (0, nsid)->r_state = RT_CONSISTENT;
 518     }
 519   /* Never allow loading a DSO in a namespace which is empty.  Such
 520      direct placements is only causing problems.  Also don't allow
 521      loading into a namespace used for auditing.  */
 522   else if (nsid != LM_ID_BASE && nsid != __LM_ID_CALLER
 523            && (GL(dl_ns)[nsid]._ns_nloaded == 0
 524                || GL(dl_ns)[nsid]._ns_loaded->l_auditing))
 525     _dl_signal_error (EINVAL, file, NULL,
 526                       N_("invalid target namespace in dlmopen()"));
 527
 528   struct dl_open_args args;
 529   args.file = file;
 530   args.mode = mode;
 531   args.caller_dlopen = caller_dlopen;
 532   args.caller_dl_open = RETURN_ADDRESS (0);
 533   args.map = NULL;
 534   args.nsid = nsid;
 535   args.argc = argc;
 536   args.argv = argv;
 537   args.env = env;
 538
 539   const char *objname;
 540   const char *errstring;
 541   bool malloced;
 542   int errcode = _dl_catch_error (&objname, &errstring, &malloced,
 543                                  dl_open_worker, &args);
 544
 545 #ifndef MAP_COPY
 546   /* We must munmap() the cache file.  */
 547   _dl_unload_cache ();
 548 #endif
 549
 550   /* Release the lock.  */
 551   __rtld_lock_unlock_recursive (GL(dl_load_lock));
 552
 553   if (__builtin_expect (errstring != NULL, 0))
 554     {
 555       /* Some error occurred during loading.  */
 556       char *local_errstring;
 557       size_t len_errstring;
 558
 559       /* Remove the object from memory.  It may be in an inconsistent
 560          state if relocation failed, for example.  */
 561       if (args.map)
 562         {
 563 #ifdef USE_TLS
 564           /* Maybe some of the modules which were loaded use TLS.
 565              Since it will be removed in the following _dl_close call
 566              we have to mark the dtv array as having gaps to fill the
 567              holes.  This is a pessimistic assumption which won't hurt
 568              if not true.  There is no need to do this when we are
 569              loading the auditing DSOs since TLS has not yet been set
 570              up.  */
 571           if ((mode & __RTLD_AUDIT) == 0)
 572             GL(dl_tls_dtv_gaps) = true;
 573 #endif
 574
 575           _dl_close (args.map);
 576         }
 577
 578       /* Make a local copy of the error string so that we can release the
 579          memory allocated for it.  */
 580       len_errstring = strlen (errstring) + 1;
 581       if (objname == errstring + len_errstring)
 582         {
 583           size_t total_len = len_errstring + strlen (objname) + 1;
 584           local_errstring = alloca (total_len);
 585           memcpy (local_errstring, errstring, total_len);
 586           objname = local_errstring + len_errstring;
 587         }
 588       else
 589         {
 590           local_errstring = alloca (len_errstring);
 591           memcpy (local_errstring, errstring, len_errstring);
 592         }
 593
 594       if (malloced)
 595         free ((char *) errstring);
 596
 597       assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
 598
 599       /* Reraise the error.  */
 600       _dl_signal_error (errcode, objname, NULL, local_errstring);
 601     }
 602
 603   assert (_dl_debug_initialize (0, args.nsid)->r_state == RT_CONSISTENT);
 604
 605 #ifndef SHARED
 606   DL_STATIC_INIT (args.map);
 607 #endif
 608
 609   return args.map;
 610 }
 611
 612
 613 #ifdef SCOPE_DEBUG
 614 #include <unistd.h>
 615
 616 static void
 617 show_scope (struct link_map *new)
 618 {
 619   int scope_cnt;
 620
 621   for (scope_cnt = 0; new->l_scope[scope_cnt] != NULL; ++scope_cnt)
 622     {
 623       char numbuf[2];
 624       unsigned int cnt;
 625
 626       numbuf[0] = '0' + scope_cnt;
 627       numbuf[1] = '\0';
 628       _dl_printf ("scope %s:", numbuf);
 629
 630       for (cnt = 0; cnt < new->l_scope[scope_cnt]->r_nlist; ++cnt)
 631         if (*new->l_scope[scope_cnt]->r_list[cnt]->l_name)
 632           _dl_printf (" %s", new->l_scope[scope_cnt]->r_list[cnt]->l_name);
 633         else
 634           _dl_printf (" <main>");
 635
 636       _dl_printf ("\n");
 637     }
 638 }
 639 #endif