1: /* Return the next shared object initializer function not yet run.
    2:    Copyright (C) 1995, 1996, 1998-2002, 2004 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 <stddef.h>
   21: #include <ldsodefs.h>
   22: 
   23: 
   24: /* Type of the initializer.  */
   25: typedef void (*init_t) (int, char **, char **);
   26: 
   27: #ifndef HAVE_INLINED_SYSCALLS
   28: /* Flag, nonzero during startup phase.  */
   29: extern int _dl_starting_up;
   30: extern int _dl_starting_up_internal attribute_hidden;
   31: #endif
   32: 
   33: 
   34: static void
   35: call_init (struct link_map *l, int argc, char **argv, char **env)
   36: {
   37:   if (l->l_init_called)
   38:     /* This object is all done.  */
   39:     return;
   40: 
   41:   /* Avoid handling this constructor again in case we have a circular
   42:      dependency.  */
   43:   l->l_init_called = 1;
   44: 
   45:   /* Check for object which constructors we do not run here.  */
   46:   if (__builtin_expect (l->l_name[0], 'a') == '\0'
   47:       && l->l_type == lt_executable)
   48:     return;
   49: 
   50:   /* Are there any constructors?  */
   51:   if (l->l_info[DT_INIT] == NULL
   52:       && __builtin_expect (l->l_info[DT_INIT_ARRAY] == NULL, 1))
   53:     return;
   54: 
   55:   /* Print a debug message if wanted.  */
   56:   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
   57:     _dl_debug_printf ("\ncalling init: %s\n\n",
   58:                       l->l_name[0] ? l->l_name : rtld_progname);
   59: 
   60:   /* Now run the local constructors.  There are two forms of them:
   61:      - the one named by DT_INIT
   62:      - the others in the DT_INIT_ARRAY.
   63:   */
   64:   if (l->l_info[DT_INIT] != NULL)
   65:     {
   66:       init_t init = (init_t) DL_DT_INIT_ADDRESS
   67:         (l, l->l_addr + l->l_info[DT_INIT]->d_un.d_ptr);
   68: 
   69:       /* Call the function.  */
   70:       init (argc, argv, env);
   71:     }
   72: 
   73:   /* Next see whether there is an array with initialization functions.  */
   74:   ElfW(Dyn) *init_array = l->l_info[DT_INIT_ARRAY];
   75:   if (init_array != NULL)
   76:     {
   77:       unsigned int j;
   78:       unsigned int jm;
   79:       ElfW(Addr) *addrs;
   80: 
   81:       jm = l->l_info[DT_INIT_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr));
   82: 
   83:       addrs = (ElfW(Addr) *) (init_array->d_un.d_ptr + l->l_addr);
   84:       for (j = 0; j < jm; ++j)
   85:         ((init_t) addrs[j]) (argc, argv, env);
   86:     }
   87: }
   88: 
   89: 
   90: void
   91: internal_function
   92: _dl_init (struct link_map *main_map, int argc, char **argv, char **env)
   93: {
   94:   ElfW(Dyn) *preinit_array = main_map->l_info[DT_PREINIT_ARRAY];
   95:   ElfW(Dyn) *preinit_array_size = main_map->l_info[DT_PREINIT_ARRAYSZ];
   96:   unsigned int i;
   97: 
   98:   if (__builtin_expect (GL(dl_initfirst) != NULL, 0))
   99:     {
  100:       call_init (GL(dl_initfirst), argc, argv, env);
  101:       GL(dl_initfirst) = NULL;
  102:     }
  103: 
  104:   /* Don't do anything if there is no preinit array.  */
  105:   if (__builtin_expect (preinit_array != NULL, 0)
  106:       && preinit_array_size != NULL
  107:       && (i = preinit_array_size->d_un.d_val / sizeof (ElfW(Addr))) > 0)
  108:     {
  109:       ElfW(Addr) *addrs;
  110:       unsigned int cnt;
  111: 
  112:       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
  113:         _dl_debug_printf ("\ncalling preinit: %s\n\n",
  114:                           main_map->l_name[0]
  115:                           ? main_map->l_name : rtld_progname);
  116: 
  117:       addrs = (ElfW(Addr) *) (preinit_array->d_un.d_ptr + main_map->l_addr);
  118:       for (cnt = 0; cnt < i; ++cnt)
  119:         ((init_t) addrs[cnt]) (argc, argv, env);
  120:     }
  121: 
  122:   /* Stupid users forced the ELF specification to be changed.  It now
  123:      says that the dynamic loader is responsible for determining the
  124:      order in which the constructors have to run.  The constructors
  125:      for all dependencies of an object must run before the constructor
  126:      for the object itself.  Circular dependencies are left unspecified.
  127: 
  128:      This is highly questionable since it puts the burden on the dynamic
  129:      loader which has to find the dependencies at runtime instead of
  130:      letting the user do it right.  Stupidity rules!  */
  131: 
  132:   i = main_map->l_searchlist.r_nlist;
  133:   while (i-- > 0)
  134:     call_init (main_map->l_initfini[i], argc, argv, env);
  135: 
  136: #ifndef HAVE_INLINED_SYSCALLS
  137:   /* Finished starting up.  */
  138:   INTUSE(_dl_starting_up) = 0;
  139: #endif
  140: }
  141: INTDEF (_dl_init)