elf/dl-deps.c

   1 /* Load the dependencies of a mapped object.
   2    Copyright (C) 1996-2015 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, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <atomic.h>
  20 #include <assert.h>
  21 #include <dlfcn.h>
  22 #include <errno.h>
  23 #include <libintl.h>
  24 #include <stddef.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <sys/param.h>
  29 #include <ldsodefs.h>
  30
  31 #include <dl-dst.h>
  32
  33 /* Whether an shared object references one or more auxiliary objects
  34    is signaled by the AUXTAG entry in l_info.  */
  35 #define AUXTAG  (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
  36                  + DT_EXTRATAGIDX (DT_AUXILIARY))
  37 /* Whether an shared object references one or more auxiliary objects
  38    is signaled by the AUXTAG entry in l_info.  */
  39 #define FILTERTAG (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
  40                    + DT_EXTRATAGIDX (DT_FILTER))
  41
  42
  43 /* When loading auxiliary objects we must ignore errors.  It's ok if
  44    an object is missing.  */
  45 struct openaux_args
  46   {
  47     /* The arguments to openaux.  */
  48     struct link_map *map;
  49     int trace_mode;
  50     int open_mode;
  51     const char *strtab;
  52     const char *name;
  53
  54     /* The return value of openaux.  */
  55     struct link_map *aux;
  56   };
  57
  58 static void
  59 openaux (void *a)
  60 {
  61   struct openaux_args *args = (struct openaux_args *) a;
  62
  63   args->aux = _dl_map_object (args->map, args->name,
  64                               (args->map->l_type == lt_executable
  65                                ? lt_library : args->map->l_type),
  66                               args->trace_mode, args->open_mode,
  67                               args->map->l_ns);
  68 }
  69
  70 static ptrdiff_t
  71 internal_function
  72 _dl_build_local_scope (struct link_map **list, struct link_map *map)
  73 {
  74   struct link_map **p = list;
  75   struct link_map **q;
  76
  77   *p++ = map;
  78   map->l_reserved = 1;
  79   if (map->l_initfini)
  80     for (q = map->l_initfini + 1; *q; ++q)
  81       if (! (*q)->l_reserved)
  82         p += _dl_build_local_scope (p, *q);
  83   return p - list;
  84 }
  85
  86
  87 /* We use a very special kind of list to track the path
  88    through the list of loaded shared objects.  We have to
  89    produce a flat list with unique members of all involved objects.
  90 */
  91 struct list
  92   {
  93     int done;                   /* Nonzero if this map was processed.  */
  94     struct link_map *map;       /* The data.  */
  95     struct list *next;          /* Elements for normal list.  */
  96   };
  97
  98
  99 /* Macro to expand DST.  It is an macro since we use `alloca'.  */
 100 #define expand_dst(l, str, fatal) \
 101   ({                                                                          \
 102     const char *__str = (str);                                                \
 103     const char *__result = __str;                                             \
 104     size_t __dst_cnt = DL_DST_COUNT (__str, 0);                               \
 105                                                                               \
 106     if (__dst_cnt != 0)                                                       \
 107       {                                                                       \
 108         char *__newp;                                                         \
 109                                                                               \
 110         /* DST must not appear in SUID/SGID programs.  */                     \
 111         if (__libc_enable_secure)                                             \
 112           _dl_signal_error (0, __str, NULL, N_("\
 113 DST not allowed in SUID/SGID programs"));                                     \
 114                                                                               \
 115         __newp = (char *) alloca (DL_DST_REQUIRED (l, __str, strlen (__str),  \
 116                                                    __dst_cnt));               \
 117                                                                               \
 118         __result = _dl_dst_substitute (l, __str, __newp, 0);                  \
 119                                                                               \
 120         if (*__result == '\0')                                                \
 121           {                                                                   \
 122             /* The replacement for the DST is not known.  We can't            \
 123                processed.  */                                                 \
 124             if (fatal)                                                        \
 125               _dl_signal_error (0, __str, NULL, N_("\
 126 empty dynamic string token substitution"));                                   \
 127             else                                                              \
 128               {                                                               \
 129                 /* This is for DT_AUXILIARY.  */                              \
 130                 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))   \
 131                   _dl_debug_printf (N_("\
 132 cannot load auxiliary `%s' because of empty dynamic string token "            \
 133                                             "substitution\n"), __str);        \
 134                 continue;                                                     \
 135               }                                                               \
 136           }                                                                   \
 137       }                                                                       \
 138                                                                               \
 139     __result; })
 140
 141 static void
 142 preload (struct list *known, unsigned int *nlist, struct link_map *map)
 143 {
 144   known[*nlist].done = 0;
 145   known[*nlist].map = map;
 146   known[*nlist].next = &known[*nlist + 1];
 147
 148   ++*nlist;
 149   /* We use `l_reserved' as a mark bit to detect objects we have
 150      already put in the search list and avoid adding duplicate
 151      elements later in the list.  */
 152   map->l_reserved = 1;
 153 }
 154
 155 void
 156 internal_function
 157 _dl_map_object_deps (struct link_map *map,
 158                      struct link_map **preloads, unsigned int npreloads,
 159                      int trace_mode, int open_mode)
 160 {
 161   struct list *known = __alloca (sizeof *known * (1 + npreloads + 1));
 162   struct list *runp, *tail;
 163   unsigned int nlist, i;
 164   /* Object name.  */
 165   const char *name;
 166   int errno_saved;
 167   int errno_reason;
 168   const char *errstring;
 169   const char *objname;
 170
 171   /* No loaded object so far.  */
 172   nlist = 0;
 173
 174   /* First load MAP itself.  */
 175   preload (known, &nlist, map);
 176
 177   /* Add the preloaded items after MAP but before any of its dependencies.  */
 178   for (i = 0; i < npreloads; ++i)
 179     preload (known, &nlist, preloads[i]);
 180
 181   /* Terminate the lists.  */
 182   known[nlist - 1].next = NULL;
 183
 184   /* Pointer to last unique object.  */
 185   tail = &known[nlist - 1];
 186
 187   /* No alloca'd space yet.  */
 188   struct link_map **needed_space = NULL;
 189   size_t needed_space_bytes = 0;
 190
 191   /* Process each element of the search list, loading each of its
 192      auxiliary objects and immediate dependencies.  Auxiliary objects
 193      will be added in the list before the object itself and
 194      dependencies will be appended to the list as we step through it.
 195      This produces a flat, ordered list that represents a
 196      breadth-first search of the dependency tree.
 197
 198      The whole process is complicated by the fact that we better
 199      should use alloca for the temporary list elements.  But using
 200      alloca means we cannot use recursive function calls.  */
 201   errno_saved = errno;
 202   errno_reason = 0;
 203   errstring = NULL;
 204   errno = 0;
 205   name = NULL;
 206   for (runp = known; runp; )
 207     {
 208       struct link_map *l = runp->map;
 209       struct link_map **needed = NULL;
 210       unsigned int nneeded = 0;
 211
 212       /* Unless otherwise stated, this object is handled.  */
 213       runp->done = 1;
 214
 215       /* Allocate a temporary record to contain the references to the
 216          dependencies of this object.  */
 217       if (l->l_searchlist.r_list == NULL && l->l_initfini == NULL
 218           && l != map && l->l_ldnum > 0)
 219         {
 220           size_t new_size = l->l_ldnum * sizeof (struct link_map *);
 221
 222           if (new_size > needed_space_bytes)
 223             needed_space
 224               = extend_alloca (needed_space, needed_space_bytes, new_size);
 225
 226           needed = needed_space;
 227         }
 228
 229       if (l->l_info[DT_NEEDED] || l->l_info[AUXTAG] || l->l_info[FILTERTAG])
 230         {
 231           const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
 232           struct openaux_args args;
 233           struct list *orig;
 234           const ElfW(Dyn) *d;
 235
 236           args.strtab = strtab;
 237           args.map = l;
 238           args.trace_mode = trace_mode;
 239           args.open_mode = open_mode;
 240           orig = runp;
 241
 242           for (d = l->l_ld; d->d_tag != DT_NULL; ++d)
 243             if (__builtin_expect (d->d_tag, DT_NEEDED) == DT_NEEDED)
 244               {
 245                 /* Map in the needed object.  */
 246                 struct link_map *dep;
 247
 248                 /* Recognize DSTs.  */
 249                 name = expand_dst (l, strtab + d->d_un.d_val, 0);
 250                 /* Store the tag in the argument structure.  */
 251                 args.name = name;
 252
 253                 bool malloced;
 254                 int err = _dl_catch_error (&objname, &errstring, &malloced,
 255                                            openaux, &args);
 256                 if (__glibc_unlikely (errstring != NULL))
 257                   {
 258                     char *new_errstring = strdupa (errstring);
 259                     objname = strdupa (objname);
 260                     if (malloced)
 261                       free ((char *) errstring);
 262                     errstring = new_errstring;
 263
 264                     if (err)
 265                       errno_reason = err;
 266                     else
 267                       errno_reason = -1;
 268                     goto out;
 269                   }
 270                 else
 271                   dep = args.aux;
 272
 273                 if (! dep->l_reserved)
 274                   {
 275                     /* Allocate new entry.  */
 276                     struct list *newp;
 277
 278                     newp = alloca (sizeof (struct list));
 279
 280                     /* Append DEP to the list.  */
 281                     newp->map = dep;
 282                     newp->done = 0;
 283                     newp->next = NULL;
 284                     tail->next = newp;
 285                     tail = newp;
 286                     ++nlist;
 287                     /* Set the mark bit that says it's already in the list.  */
 288                     dep->l_reserved = 1;
 289                   }
 290
 291                 /* Remember this dependency.  */
 292                 if (needed != NULL)
 293                   needed[nneeded++] = dep;
 294               }
 295             else if (d->d_tag == DT_AUXILIARY || d->d_tag == DT_FILTER)
 296               {
 297                 struct list *newp;
 298
 299                 /* Recognize DSTs.  */
 300                 name = expand_dst (l, strtab + d->d_un.d_val,
 301                                    d->d_tag == DT_AUXILIARY);
 302                 /* Store the tag in the argument structure.  */
 303                 args.name = name;
 304
 305                 /* Say that we are about to load an auxiliary library.  */
 306                 if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS,
 307                                       0))
 308                   _dl_debug_printf ("load auxiliary object=%s"
 309                                     " requested by file=%s\n",
 310                                     name,
 311                                     DSO_FILENAME (l->l_name));
 312
 313                 /* We must be prepared that the addressed shared
 314                    object is not available.  For filter objects the dependency
 315                    must be available.  */
 316                 bool malloced;
 317                 int err = _dl_catch_error (&objname, &errstring, &malloced,
 318                                         openaux, &args);
 319
 320                 if (__glibc_unlikely (errstring != NULL))
 321                   {
 322                     if (d->d_tag == DT_AUXILIARY)
 323                       {
 324                         /* We are not interested in the error message.  */
 325                         assert (errstring != NULL);
 326                         if (malloced)
 327                           free ((char *) errstring);
 328
 329                         /* Simply ignore this error and continue the work.  */
 330                         continue;
 331                       }
 332                     else
 333                       {
 334
 335                         char *new_errstring = strdupa (errstring);
 336                         objname = strdupa (objname);
 337                         if (malloced)
 338                           free ((char *) errstring);
 339                         errstring = new_errstring;
 340
 341                         if (err)
 342                           errno_reason = err;
 343                         else
 344                           errno_reason = -1;
 345                         goto out;
 346                       }
 347                   }
 348
 349                 /* The auxiliary object is actually available.
 350                    Incorporate the map in all the lists.  */
 351
 352                 /* Allocate new entry.  This always has to be done.  */
 353                 newp = alloca (sizeof (struct list));
 354
 355                 /* We want to insert the new map before the current one,
 356                    but we have no back links.  So we copy the contents of
 357                    the current entry over.  Note that ORIG and NEWP now
 358                    have switched their meanings.  */
 359                 memcpy (newp, orig, sizeof (*newp));
 360
 361                 /* Initialize new entry.  */
 362                 orig->done = 0;
 363                 orig->map = args.aux;
 364
 365                 /* Remember this dependency.  */
 366                 if (needed != NULL)
 367                   needed[nneeded++] = args.aux;
 368
 369                 /* We must handle two situations here: the map is new,
 370                    so we must add it in all three lists.  If the map
 371                    is already known, we have two further possibilities:
 372                    - if the object is before the current map in the
 373                    search list, we do nothing.  It is already found
 374                    early
 375                    - if the object is after the current one, we must
 376                    move it just before the current map to make sure
 377                    the symbols are found early enough
 378                 */
 379                 if (args.aux->l_reserved)
 380                   {
 381                     /* The object is already somewhere in the list.
 382                        Locate it first.  */
 383                     struct list *late;
 384
 385                     /* This object is already in the search list we
 386                        are building.  Don't add a duplicate pointer.
 387                        Just added by _dl_map_object.  */
 388                     for (late = newp; late->next != NULL; late = late->next)
 389                       if (late->next->map == args.aux)
 390                         break;
 391
 392                     if (late->next != NULL)
 393                       {
 394                         /* The object is somewhere behind the current
 395                            position in the search path.  We have to
 396                            move it to this earlier position.  */
 397                         orig->next = newp;
 398
 399                         /* Now remove the later entry from the list
 400                            and adjust the tail pointer.  */
 401                         if (tail == late->next)
 402                           tail = late;
 403                         late->next = late->next->next;
 404
 405                         /* We must move the object earlier in the chain.  */
 406                         if (args.aux->l_prev != NULL)
 407                           args.aux->l_prev->l_next = args.aux->l_next;
 408                         if (args.aux->l_next != NULL)
 409                           args.aux->l_next->l_prev = args.aux->l_prev;
 410
 411                         args.aux->l_prev = newp->map->l_prev;
 412                         newp->map->l_prev = args.aux;
 413                         if (args.aux->l_prev != NULL)
 414                           args.aux->l_prev->l_next = args.aux;
 415                         args.aux->l_next = newp->map;
 416                       }
 417                     else
 418                       {
 419                         /* The object must be somewhere earlier in the
 420                            list.  Undo to the current list element what
 421                            we did above.  */
 422                         memcpy (orig, newp, sizeof (*newp));
 423                         continue;
 424                       }
 425                   }
 426                 else
 427                   {
 428                     /* This is easy.  We just add the symbol right here.  */
 429                     orig->next = newp;
 430                     ++nlist;
 431                     /* Set the mark bit that says it's already in the list.  */
 432                     args.aux->l_reserved = 1;
 433
 434                     /* The only problem is that in the double linked
 435                        list of all objects we don't have this new
 436                        object at the correct place.  Correct this here.  */
 437                     if (args.aux->l_prev)
 438                       args.aux->l_prev->l_next = args.aux->l_next;
 439                     if (args.aux->l_next)
 440                       args.aux->l_next->l_prev = args.aux->l_prev;
 441
 442                     args.aux->l_prev = newp->map->l_prev;
 443                     newp->map->l_prev = args.aux;
 444                     if (args.aux->l_prev != NULL)
 445                       args.aux->l_prev->l_next = args.aux;
 446                     args.aux->l_next = newp->map;
 447                   }
 448
 449                 /* Move the tail pointer if necessary.  */
 450                 if (orig == tail)
 451                   tail = newp;
 452
 453                 /* Move on the insert point.  */
 454                 orig = newp;
 455               }
 456         }
 457
 458       /* Terminate the list of dependencies and store the array address.  */
 459       if (needed != NULL)
 460         {
 461           needed[nneeded++] = NULL;
 462
 463           struct link_map **l_initfini = (struct link_map **)
 464             malloc ((2 * nneeded + 1) * sizeof needed[0]);
 465           if (l_initfini == NULL)
 466             _dl_signal_error (ENOMEM, map->l_name, NULL,
 467                               N_("cannot allocate dependency list"));
 468           l_initfini[0] = l;
 469           memcpy (&l_initfini[1], needed, nneeded * sizeof needed[0]);
 470           memcpy (&l_initfini[nneeded + 1], l_initfini,
 471                   nneeded * sizeof needed[0]);
 472           atomic_write_barrier ();
 473           l->l_initfini = l_initfini;
 474           l->l_free_initfini = 1;
 475         }
 476
 477       /* If we have no auxiliary objects just go on to the next map.  */
 478       if (runp->done)
 479         do
 480           runp = runp->next;
 481         while (runp != NULL && runp->done);
 482     }
 483
 484  out:
 485   if (errno == 0 && errno_saved != 0)
 486     __set_errno (errno_saved);
 487
 488   struct link_map **old_l_initfini = NULL;
 489   if (map->l_initfini != NULL && map->l_type == lt_loaded)
 490     {
 491       /* This object was previously loaded as a dependency and we have
 492          a separate l_initfini list.  We don't need it anymore.  */
 493       assert (map->l_searchlist.r_list == NULL);
 494       old_l_initfini = map->l_initfini;
 495     }
 496
 497   /* Store the search list we built in the object.  It will be used for
 498      searches in the scope of this object.  */
 499   struct link_map **l_initfini =
 500     (struct link_map **) malloc ((2 * nlist + 1)
 501                                  * sizeof (struct link_map *));
 502   if (l_initfini == NULL)
 503     _dl_signal_error (ENOMEM, map->l_name, NULL,
 504                       N_("cannot allocate symbol search list"));
 505
 506
 507   map->l_searchlist.r_list = &l_initfini[nlist + 1];
 508   map->l_searchlist.r_nlist = nlist;
 509
 510   for (nlist = 0, runp = known; runp; runp = runp->next)
 511     {
 512       if (__builtin_expect (trace_mode, 0) && runp->map->l_faked)
 513         /* This can happen when we trace the loading.  */
 514         --map->l_searchlist.r_nlist;
 515       else
 516         map->l_searchlist.r_list[nlist++] = runp->map;
 517
 518       /* Now clear all the mark bits we set in the objects on the search list
 519          to avoid duplicates, so the next call starts fresh.  */
 520       runp->map->l_reserved = 0;
 521     }
 522
 523   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK, 0) != 0
 524       && map == GL(dl_ns)[LM_ID_BASE]._ns_loaded)
 525     {
 526       /* If we are to compute conflicts, we have to build local scope
 527          for each library, not just the ultimate loader.  */
 528       for (i = 0; i < nlist; ++i)
 529         {
 530           struct link_map *l = map->l_searchlist.r_list[i];
 531           unsigned int j, cnt;
 532
 533           /* The local scope has been already computed.  */
 534           if (l == map
 535               || (l->l_local_scope[0]
 536                   && l->l_local_scope[0]->r_nlist) != 0)
 537             continue;
 538
 539           if (l->l_info[AUXTAG] || l->l_info[FILTERTAG])
 540             {
 541               /* As current DT_AUXILIARY/DT_FILTER implementation needs to be
 542                  rewritten, no need to bother with prelinking the old
 543                  implementation.  */
 544               _dl_signal_error (EINVAL, l->l_name, NULL, N_("\
 545 Filters not supported with LD_TRACE_PRELINKING"));
 546             }
 547
 548           cnt = _dl_build_local_scope (l_initfini, l);
 549           assert (cnt <= nlist);
 550           for (j = 0; j < cnt; j++)
 551             {
 552               l_initfini[j]->l_reserved = 0;
 553               if (j && __builtin_expect (l_initfini[j]->l_info[DT_SYMBOLIC]
 554                                          != NULL, 0))
 555                 l->l_symbolic_in_local_scope = true;
 556             }
 557
 558           l->l_local_scope[0] =
 559             (struct r_scope_elem *) malloc (sizeof (struct r_scope_elem)
 560                                             + (cnt
 561                                                * sizeof (struct link_map *)));
 562           if (l->l_local_scope[0] == NULL)
 563             _dl_signal_error (ENOMEM, map->l_name, NULL,
 564                               N_("cannot allocate symbol search list"));
 565           l->l_local_scope[0]->r_nlist = cnt;
 566           l->l_local_scope[0]->r_list =
 567             (struct link_map **) (l->l_local_scope[0] + 1);
 568           memcpy (l->l_local_scope[0]->r_list, l_initfini,
 569                   cnt * sizeof (struct link_map *));
 570         }
 571     }
 572
 573   /* Maybe we can remove some relocation dependencies now.  */
 574   assert (map->l_searchlist.r_list[0] == map);
 575   struct link_map_reldeps *l_reldeps = NULL;
 576   if (map->l_reldeps != NULL)
 577     {
 578       for (i = 1; i < nlist; ++i)
 579         map->l_searchlist.r_list[i]->l_reserved = 1;
 580
 581       struct link_map **list = &map->l_reldeps->list[0];
 582       for (i = 0; i < map->l_reldeps->act; ++i)
 583         if (list[i]->l_reserved)
 584           {
 585             /* Need to allocate new array of relocation dependencies.  */
 586             l_reldeps = malloc (sizeof (*l_reldeps)
 587                                 + map->l_reldepsmax
 588                                   * sizeof (struct link_map *));
 589             if (l_reldeps == NULL)
 590               /* Bad luck, keep the reldeps duplicated between
 591                  map->l_reldeps->list and map->l_initfini lists.  */
 592               ;
 593             else
 594               {
 595                 unsigned int j = i;
 596                 memcpy (&l_reldeps->list[0], &list[0],
 597                         i * sizeof (struct link_map *));
 598                 for (i = i + 1; i < map->l_reldeps->act; ++i)
 599                   if (!list[i]->l_reserved)
 600                     l_reldeps->list[j++] = list[i];
 601                 l_reldeps->act = j;
 602               }
 603           }
 604
 605       for (i = 1; i < nlist; ++i)
 606         map->l_searchlist.r_list[i]->l_reserved = 0;
 607     }
 608
 609   /* Sort the initializer list to take dependencies into account.  The binary
 610      itself will always be initialize last.  */
 611   memcpy (l_initfini, map->l_searchlist.r_list,
 612           nlist * sizeof (struct link_map *));
 613   if (__glibc_likely (nlist > 1))
 614     {
 615       /* We can skip looking for the binary itself which is at the front
 616          of the search list.  */
 617       i = 1;
 618       uint16_t seen[nlist];
 619       memset (seen, 0, nlist * sizeof (seen[0]));
 620       while (1)
 621         {
 622           /* Keep track of which object we looked at this round.  */
 623           ++seen[i];
 624           struct link_map *thisp = l_initfini[i];
 625
 626           /* Find the last object in the list for which the current one is
 627              a dependency and move the current object behind the object
 628              with the dependency.  */
 629           unsigned int k = nlist - 1;
 630           while (k > i)
 631             {
 632               struct link_map **runp = l_initfini[k]->l_initfini;
 633               if (runp != NULL)
 634                 /* Look through the dependencies of the object.  */
 635                 while (*runp != NULL)
 636                   if (__glibc_unlikely (*runp++ == thisp))
 637                     {
 638                       /* Move the current object to the back past the last
 639                          object with it as the dependency.  */
 640                       memmove (&l_initfini[i], &l_initfini[i + 1],
 641                                (k - i) * sizeof (l_initfini[0]));
 642                       l_initfini[k] = thisp;
 643
 644                       if (seen[i + 1] > nlist - i)
 645                         {
 646                           ++i;
 647                           goto next_clear;
 648                         }
 649
 650                       uint16_t this_seen = seen[i];
 651                       memmove (&seen[i], &seen[i + 1],
 652                                (k - i) * sizeof (seen[0]));
 653                       seen[k] = this_seen;
 654
 655                       goto next;
 656                     }
 657
 658               --k;
 659             }
 660
 661           if (++i == nlist)
 662             break;
 663         next_clear:
 664           memset (&seen[i], 0, (nlist - i) * sizeof (seen[0]));
 665
 666         next:;
 667         }
 668     }
 669
 670   /* Terminate the list of dependencies.  */
 671   l_initfini[nlist] = NULL;
 672   atomic_write_barrier ();
 673   map->l_initfini = l_initfini;
 674   map->l_free_initfini = 1;
 675   if (l_reldeps != NULL)
 676     {
 677       atomic_write_barrier ();
 678       void *old_l_reldeps = map->l_reldeps;
 679       map->l_reldeps = l_reldeps;
 680       _dl_scope_free (old_l_reldeps);
 681     }
 682   if (old_l_initfini != NULL)
 683     _dl_scope_free (old_l_initfini);
 684
 685   if (errno_reason)
 686     _dl_signal_error (errno_reason == -1 ? 0 : errno_reason, objname,
 687                       NULL, errstring);
 688 }