"empty dynamics string token substitution");
"empty dynamic string token substitution");
weak_extern (_dl_sysdep_start)/* This function is used to unload the cache file if necessary.  */extern void _dl_unload_cache (void);extern int __libc_multiple_libcs;	/* Defined in init-first.c.  */extern int __libc_argc;extern char **__libc_argv;extern char **__environ;extern int _dl_lazy;			/* Do we do lazy relocations?  *//* Undefine the following for debugging.  *//* #define SCOPE_DEBUG 1 */#ifdef SCOPE_DEBUGstatic void show_scope (struct link_map *new);#endif/* During the program run we must not modify the global data of   loaded shared object simultanously in two threads.  Therefore we   protect `_dl_open' and `_dl_close' in dl-close.c.   This must be a recursive lock since the initializer function of   the loaded object might as well require a call to this function.   At this time it is not anymore a problem to modify the tables.  */__libc_lock_define_initialized_recursive (, _dl_load_lock)extern size_t _dl_platformlen;/* We must be carefull not to leave us in an inconsistent state.  Thus we   catch any error and re-raise it after cleaning up.  */struct dl_open_args{  const char *file;  int mode;  const void *caller;  struct link_map *map;};static voiddl_open_worker (void *a){  struct dl_open_args *args = a;  const char *file = args->file;  int mode = args->mode;  struct link_map *new, *l;  ElfW(Addr) init;  struct r_debug *r;  unsigned int global_add;  const char *dst;  int lazy;  /* Maybe we have to expand a DST.  */  dst = strchr (file, '$');  if (dst != NULL)    {      const void *caller = args->caller;      size_t len = strlen (file);      size_t required;      struct link_map *call_map;      char *new_file;      /* We have to find out from which object the caller is calling.	 Find the highest-addressed object that ADDRESS is not below.  */      call_map = NULL;      for (l = _dl_loaded; l; l = l->l_next)	if (l->l_addr != 0 /* Make sure we do not currently set this map up			      in this moment.  */	    && caller >= (const void *) l->l_addr	    && (call_map == NULL || call_map->l_addr < l->l_addr))	  call_map = l;      if (call_map == NULL)	/* In this case we assume this is the main application.  */	call_map = _dl_loaded;      /* Determine how much space we need.  We have to allocate the	 memory locally.  */      required = DL_DST_REQUIRED (call_map, file, len, _dl_dst_count (dst, 0));      /* Get space for the new file name.  */      new_file = (char *) alloca (required + 1);      /* Generate the new file name.  */      DL_DST_SUBSTITUTE (call_map, file, new_file, 0);      /* If the substitution failed don't try to load.  */      if (*new_file == '\0')	_dl_signal_error (0, "dlopen",			  "empty dynamics string token substitution");      /* Now we have a new file name.  */      file = new_file;    }  /* Load the named object.  */  args->map = new = _dl_map_object (NULL, file, 0, lt_loaded, 0);  if (new->l_searchlist.r_list)    /* It was already open.  */    return;  /* Load that object's dependencies.  */  global_add = _dl_map_object_deps (new, NULL, 0, 0, mode & RTLD_GLOBAL);  /* So far, so good.  Now check the versions.  */  (void) _dl_check_all_versions (new, 0);#ifdef SCOPE_DEBUG  show_scope (new);#endif  /* Only do lazy relocation if `LD_BIND_NOW' is not set.  */  lazy = (mode & RTLD_BINDING_MASK) == RTLD_LAZY && _dl_lazy;  /* Relocate the objects loaded.  We do this in reverse order so that copy     relocs of earlier objects overwrite the data written by later objects.  */  l = new;  while (l->l_next)    l = l->l_next;  while (1)    {      if (! l->l_relocated)	{#ifdef PIC	  if (_dl_profile != NULL)	    {	      /* If this here is the shared object which we want to profile		 make sure the profile is started.  We can find out whether	         this is necessary or not by observing the `_dl_profile_map'	         variable.  If was NULL but is not NULL afterwars we must		 start the profiling.  */	      struct link_map *old_profile_map = _dl_profile_map;	      _dl_relocate_object (l, l->l_scope, 1, 1);	      if (old_profile_map == NULL && _dl_profile_map != NULL)		/* We must prepare the profiling.  */		_dl_start_profile (_dl_profile_map, _dl_profile_output);	    }	  else#endif	    _dl_relocate_object (l, l->l_scope, lazy, 0);	}      if (l == new)	break;      l = l->l_prev;    }  /* Notify the debugger we have added some objects.  We need to call     _dl_debug_initialize in a static program in case dynamic linking has     not been used before.  */  r = _dl_debug_initialize (0);  r->r_state = RT_ADD;  _dl_debug_state ();  /* Run the initializer functions of new objects.  */  while ((init = _dl_init_next (&new->l_searchlist)))    (*(void (*) (int, char **, char **)) init) (__libc_argc, __libc_argv,						__environ);  /* Now we can make the new map available in the global scope.  */  while (global_add-- > 0)    _dl_main_searchlist->r_list[_dl_main_searchlist->r_nlist++]->l_global = 1;  if (_dl_sysdep_start == NULL)    /* We must be the static _dl_open in libc.a.  A static program that       has loaded a dynamic object now has competition.  */    __libc_multiple_libcs = 1;}