elf/dl-open.c

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