bfd/elflink.h

   1 /* ELF linker support.
   2    Copyright 1995, 1996, 1997 Free Software Foundation, Inc.
   3
   4 This file is part of BFD, the Binary File Descriptor library.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 /* ELF linker code.  */
  21
  22 /* This struct is used to pass information to routines called via
  23    elf_link_hash_traverse which must return failure.  */
  24
  25 struct elf_info_failed
  26 {
  27   boolean failed;
  28   struct bfd_link_info *info;
  29 };
  30
  31 static boolean elf_link_add_object_symbols
  32   PARAMS ((bfd *, struct bfd_link_info *));
  33 static boolean elf_link_add_archive_symbols
  34   PARAMS ((bfd *, struct bfd_link_info *));
  35 static boolean elf_merge_symbol
  36   PARAMS ((bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *,
  37            asection **, bfd_vma *, struct elf_link_hash_entry **,
  38            boolean *, boolean *, boolean *));
  39 static boolean elf_export_symbol
  40   PARAMS ((struct elf_link_hash_entry *, PTR));
  41 static boolean elf_fix_symbol_flags
  42   PARAMS ((struct elf_link_hash_entry *, struct elf_info_failed *));
  43 static boolean elf_adjust_dynamic_symbol
  44   PARAMS ((struct elf_link_hash_entry *, PTR));
  45 static boolean elf_link_find_version_dependencies
  46   PARAMS ((struct elf_link_hash_entry *, PTR));
  47 static boolean elf_link_find_version_dependencies
  48   PARAMS ((struct elf_link_hash_entry *, PTR));
  49 static boolean elf_link_assign_sym_version
  50   PARAMS ((struct elf_link_hash_entry *, PTR));
  51 static boolean elf_link_renumber_dynsyms
  52   PARAMS ((struct elf_link_hash_entry *, PTR));
  53
  54 /* Given an ELF BFD, add symbols to the global hash table as
  55    appropriate.  */
  56
  57 boolean
  58 elf_bfd_link_add_symbols (abfd, info)
  59      bfd *abfd;
  60      struct bfd_link_info *info;
  61 {
  62   switch (bfd_get_format (abfd))
  63     {
  64     case bfd_object:
  65       return elf_link_add_object_symbols (abfd, info);
  66     case bfd_archive:
  67       return elf_link_add_archive_symbols (abfd, info);
  68     default:
  69       bfd_set_error (bfd_error_wrong_format);
  70       return false;
  71     }
  72 }
  73 \f
  74
  75 /* Add symbols from an ELF archive file to the linker hash table.  We
  76    don't use _bfd_generic_link_add_archive_symbols because of a
  77    problem which arises on UnixWare.  The UnixWare libc.so is an
  78    archive which includes an entry libc.so.1 which defines a bunch of
  79    symbols.  The libc.so archive also includes a number of other
  80    object files, which also define symbols, some of which are the same
  81    as those defined in libc.so.1.  Correct linking requires that we
  82    consider each object file in turn, and include it if it defines any
  83    symbols we need.  _bfd_generic_link_add_archive_symbols does not do
  84    this; it looks through the list of undefined symbols, and includes
  85    any object file which defines them.  When this algorithm is used on
  86    UnixWare, it winds up pulling in libc.so.1 early and defining a
  87    bunch of symbols.  This means that some of the other objects in the
  88    archive are not included in the link, which is incorrect since they
  89    precede libc.so.1 in the archive.
  90
  91    Fortunately, ELF archive handling is simpler than that done by
  92    _bfd_generic_link_add_archive_symbols, which has to allow for a.out
  93    oddities.  In ELF, if we find a symbol in the archive map, and the
  94    symbol is currently undefined, we know that we must pull in that
  95    object file.
  96
  97    Unfortunately, we do have to make multiple passes over the symbol
  98    table until nothing further is resolved.  */
  99
 100 static boolean
 101 elf_link_add_archive_symbols (abfd, info)
 102      bfd *abfd;
 103      struct bfd_link_info *info;
 104 {
 105   symindex c;
 106   boolean *defined = NULL;
 107   boolean *included = NULL;
 108   carsym *symdefs;
 109   boolean loop;
 110
 111   if (! bfd_has_map (abfd))
 112     {
 113       /* An empty archive is a special case.  */
 114       if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
 115         return true;
 116       bfd_set_error (bfd_error_no_armap);
 117       return false;
 118     }
 119
 120   /* Keep track of all symbols we know to be already defined, and all
 121      files we know to be already included.  This is to speed up the
 122      second and subsequent passes.  */
 123   c = bfd_ardata (abfd)->symdef_count;
 124   if (c == 0)
 125     return true;
 126   defined = (boolean *) bfd_malloc (c * sizeof (boolean));
 127   included = (boolean *) bfd_malloc (c * sizeof (boolean));
 128   if (defined == (boolean *) NULL || included == (boolean *) NULL)
 129     goto error_return;
 130   memset (defined, 0, c * sizeof (boolean));
 131   memset (included, 0, c * sizeof (boolean));
 132
 133   symdefs = bfd_ardata (abfd)->symdefs;
 134
 135   do
 136     {
 137       file_ptr last;
 138       symindex i;
 139       carsym *symdef;
 140       carsym *symdefend;
 141
 142       loop = false;
 143       last = -1;
 144
 145       symdef = symdefs;
 146       symdefend = symdef + c;
 147       for (i = 0; symdef < symdefend; symdef++, i++)
 148         {
 149           struct elf_link_hash_entry *h;
 150           bfd *element;
 151           struct bfd_link_hash_entry *undefs_tail;
 152           symindex mark;
 153
 154           if (defined[i] || included[i])
 155             continue;
 156           if (symdef->file_offset == last)
 157             {
 158               included[i] = true;
 159               continue;
 160             }
 161
 162           h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
 163                                     false, false, false);
 164
 165           if (h == NULL)
 166             {
 167               char *p, *copy;
 168
 169               /* If this is a default version (the name contains @@),
 170                  look up the symbol again without the version.  The
 171                  effect is that references to the symbol without the
 172                  version will be matched by the default symbol in the
 173                  archive.  */
 174
 175               p = strchr (symdef->name, ELF_VER_CHR);
 176               if (p == NULL || p[1] != ELF_VER_CHR)
 177                 continue;
 178
 179               copy = bfd_alloc (abfd, p - symdef->name + 1);
 180               if (copy == NULL)
 181                 goto error_return;
 182               memcpy (copy, symdef->name, p - symdef->name);
 183               copy[p - symdef->name] = '\0';
 184
 185               h = elf_link_hash_lookup (elf_hash_table (info), copy,
 186                                         false, false, false);
 187
 188               bfd_release (abfd, copy);
 189             }
 190
 191           if (h == NULL)
 192             continue;
 193
 194           if (h->root.type != bfd_link_hash_undefined)
 195             {
 196               if (h->root.type != bfd_link_hash_undefweak)
 197                 defined[i] = true;
 198               continue;
 199             }
 200
 201           /* We need to include this archive member.  */
 202
 203           element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
 204           if (element == (bfd *) NULL)
 205             goto error_return;
 206
 207           if (! bfd_check_format (element, bfd_object))
 208             goto error_return;
 209
 210           /* Doublecheck that we have not included this object
 211              already--it should be impossible, but there may be
 212              something wrong with the archive.  */
 213           if (element->archive_pass != 0)
 214             {
 215               bfd_set_error (bfd_error_bad_value);
 216               goto error_return;
 217             }
 218           element->archive_pass = 1;
 219
 220           undefs_tail = info->hash->undefs_tail;
 221
 222           if (! (*info->callbacks->add_archive_element) (info, element,
 223                                                          symdef->name))
 224             goto error_return;
 225           if (! elf_link_add_object_symbols (element, info))
 226             goto error_return;
 227
 228           /* If there are any new undefined symbols, we need to make
 229              another pass through the archive in order to see whether
 230              they can be defined.  FIXME: This isn't perfect, because
 231              common symbols wind up on undefs_tail and because an
 232              undefined symbol which is defined later on in this pass
 233              does not require another pass.  This isn't a bug, but it
 234              does make the code less efficient than it could be.  */
 235           if (undefs_tail != info->hash->undefs_tail)
 236             loop = true;
 237
 238           /* Look backward to mark all symbols from this object file
 239              which we have already seen in this pass.  */
 240           mark = i;
 241           do
 242             {
 243               included[mark] = true;
 244               if (mark == 0)
 245                 break;
 246               --mark;
 247             }
 248           while (symdefs[mark].file_offset == symdef->file_offset);
 249
 250           /* We mark subsequent symbols from this object file as we go
 251              on through the loop.  */
 252           last = symdef->file_offset;
 253         }
 254     }
 255   while (loop);
 256
 257   free (defined);
 258   free (included);
 259
 260   return true;
 261
 262  error_return:
 263   if (defined != (boolean *) NULL)
 264     free (defined);
 265   if (included != (boolean *) NULL)
 266     free (included);
 267   return false;
 268 }
 269
 270 /* This function is called when we want to define a new symbol.  It
 271    handles the various cases which arise when we find a definition in
 272    a dynamic object, or when there is already a definition in a
 273    dynamic object.  The new symbol is described by NAME, SYM, PSEC,
 274    and PVALUE.  We set SYM_HASH to the hash table entry.  We set
 275    OVERRIDE if the old symbol is overriding a new definition.  We set
 276    TYPE_CHANGE_OK if it is OK for the type to change.  We set
 277    SIZE_CHANGE_OK if it is OK for the size to change.  By OK to
 278    change, we mean that we shouldn't warn if the type or size does
 279    change.  */
 280
 281 static boolean
 282 elf_merge_symbol (abfd, info, name, sym, psec, pvalue, sym_hash,
 283                   override, type_change_ok, size_change_ok)
 284      bfd *abfd;
 285      struct bfd_link_info *info;
 286      const char *name;
 287      Elf_Internal_Sym *sym;
 288      asection **psec;
 289      bfd_vma *pvalue;
 290      struct elf_link_hash_entry **sym_hash;
 291      boolean *override;
 292      boolean *type_change_ok;
 293      boolean *size_change_ok;
 294 {
 295   asection *sec;
 296   struct elf_link_hash_entry *h;
 297   int bind;
 298   bfd *oldbfd;
 299   boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
 300
 301   /* This code is for coping with dynamic objects, and is only useful
 302      if we are doing an ELF link.  */
 303   if (info->hash->creator != abfd->xvec)
 304     return true;
 305
 306   *override = false;
 307   *type_change_ok = false;
 308   *size_change_ok = false;
 309
 310   sec = *psec;
 311   bind = ELF_ST_BIND (sym->st_info);
 312
 313   if (! bfd_is_und_section (sec))
 314     h = elf_link_hash_lookup (elf_hash_table (info), name, true, false, false);
 315   else
 316     h = ((struct elf_link_hash_entry *)
 317          bfd_wrapped_link_hash_lookup (abfd, info, name, true, false, false));
 318   if (h == NULL)
 319     return false;
 320   *sym_hash = h;
 321
 322   /* For merging, we only care about real symbols.  */
 323
 324   while (h->root.type == bfd_link_hash_indirect
 325          || h->root.type == bfd_link_hash_warning)
 326     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 327
 328   /* If we just created the symbol, mark it as being an ELF symbol.
 329      Other than that, there is nothing to do--there is no merge issue
 330      with a newly defined symbol--so we just return.  */
 331
 332   if (h->root.type == bfd_link_hash_new)
 333     {
 334       h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
 335       return true;
 336     }
 337
 338   /* OLDBFD is a BFD associated with the existing symbol.  */
 339
 340   switch (h->root.type)
 341     {
 342     default:
 343       oldbfd = NULL;
 344       break;
 345
 346     case bfd_link_hash_undefined:
 347     case bfd_link_hash_undefweak:
 348       oldbfd = h->root.u.undef.abfd;
 349       break;
 350
 351     case bfd_link_hash_defined:
 352     case bfd_link_hash_defweak:
 353       oldbfd = h->root.u.def.section->owner;
 354       break;
 355
 356     case bfd_link_hash_common:
 357       oldbfd = h->root.u.c.p->section->owner;
 358       break;
 359     }
 360
 361   /* NEWDYN and OLDDYN indicate whether the new or old symbol,
 362      respectively, is from a dynamic object.  */
 363
 364   if ((abfd->flags & DYNAMIC) != 0)
 365     newdyn = true;
 366   else
 367     newdyn = false;
 368
 369   if (oldbfd == NULL || (oldbfd->flags & DYNAMIC) == 0)
 370     olddyn = false;
 371   else
 372     olddyn = true;
 373
 374   /* NEWDEF and OLDDEF indicate whether the new or old symbol,
 375      respectively, appear to be a definition rather than reference.  */
 376
 377   if (bfd_is_und_section (sec) || bfd_is_com_section (sec))
 378     newdef = false;
 379   else
 380     newdef = true;
 381
 382   if (h->root.type == bfd_link_hash_undefined
 383       || h->root.type == bfd_link_hash_undefweak
 384       || h->root.type == bfd_link_hash_common)
 385     olddef = false;
 386   else
 387     olddef = true;
 388
 389   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
 390      symbol, respectively, appears to be a common symbol in a dynamic
 391      object.  If a symbol appears in an uninitialized section, and is
 392      not weak, and is not a function, then it may be a common symbol
 393      which was resolved when the dynamic object was created.  We want
 394      to treat such symbols specially, because they raise special
 395      considerations when setting the symbol size: if the symbol
 396      appears as a common symbol in a regular object, and the size in
 397      the regular object is larger, we must make sure that we use the
 398      larger size.  This problematic case can always be avoided in C,
 399      but it must be handled correctly when using Fortran shared
 400      libraries.
 401
 402      Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
 403      likewise for OLDDYNCOMMON and OLDDEF.
 404
 405      Note that this test is just a heuristic, and that it is quite
 406      possible to have an uninitialized symbol in a shared object which
 407      is really a definition, rather than a common symbol.  This could
 408      lead to some minor confusion when the symbol really is a common
 409      symbol in some regular object.  However, I think it will be
 410      harmless.  */
 411
 412   if (newdyn
 413       && newdef
 414       && (sec->flags & SEC_ALLOC) != 0
 415       && (sec->flags & SEC_LOAD) == 0
 416       && sym->st_size > 0
 417       && bind != STB_WEAK
 418       && ELF_ST_TYPE (sym->st_info) != STT_FUNC)
 419     newdyncommon = true;
 420   else
 421     newdyncommon = false;
 422
 423   if (olddyn
 424       && olddef
 425       && h->root.type == bfd_link_hash_defined
 426       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 427       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
 428       && (h->root.u.def.section->flags & SEC_LOAD) == 0
 429       && h->size > 0
 430       && h->type != STT_FUNC)
 431     olddyncommon = true;
 432   else
 433     olddyncommon = false;
 434
 435   /* It's OK to change the type if either the existing symbol or the
 436      new symbol is weak.  */
 437
 438   if (h->root.type == bfd_link_hash_defweak
 439       || h->root.type == bfd_link_hash_undefweak
 440       || bind == STB_WEAK)
 441     *type_change_ok = true;
 442
 443   /* It's OK to change the size if either the existing symbol or the
 444      new symbol is weak, or if the old symbol is undefined.  */
 445
 446   if (*type_change_ok
 447       || h->root.type == bfd_link_hash_undefined)
 448     *size_change_ok = true;
 449
 450   /* If both the old and the new symbols look like common symbols in a
 451      dynamic object, set the size of the symbol to the larger of the
 452      two.  */
 453
 454   if (olddyncommon
 455       && newdyncommon
 456       && sym->st_size != h->size)
 457     {
 458       /* Since we think we have two common symbols, issue a multiple
 459          common warning if desired.  Note that we only warn if the
 460          size is different.  If the size is the same, we simply let
 461          the old symbol override the new one as normally happens with
 462          symbols defined in dynamic objects.  */
 463
 464       if (! ((*info->callbacks->multiple_common)
 465              (info, h->root.root.string, oldbfd, bfd_link_hash_common,
 466               h->size, abfd, bfd_link_hash_common, sym->st_size)))
 467         return false;
 468
 469       if (sym->st_size > h->size)
 470         h->size = sym->st_size;
 471
 472       *size_change_ok = true;
 473     }
 474
 475   /* If we are looking at a dynamic object, and we have found a
 476      definition, we need to see if the symbol was already defined by
 477      some other object.  If so, we want to use the existing
 478      definition, and we do not want to report a multiple symbol
 479      definition error; we do this by clobbering *PSEC to be
 480      bfd_und_section_ptr.
 481
 482      We treat a common symbol as a definition if the symbol in the
 483      shared library is a function, since common symbols always
 484      represent variables; this can cause confusion in principle, but
 485      any such confusion would seem to indicate an erroneous program or
 486      shared library.  We also permit a common symbol in a regular
 487      object to override a weak symbol in a shared object.  */
 488
 489   if (newdyn
 490       && newdef
 491       && (olddef
 492           || (h->root.type == bfd_link_hash_common
 493               && (bind == STB_WEAK
 494                   || ELF_ST_TYPE (sym->st_info) == STT_FUNC))))
 495     {
 496       *override = true;
 497       newdef = false;
 498       newdyncommon = false;
 499
 500       *psec = sec = bfd_und_section_ptr;
 501       *size_change_ok = true;
 502
 503       /* If we get here when the old symbol is a common symbol, then
 504          we are explicitly letting it override a weak symbol or
 505          function in a dynamic object, and we don't want to warn about
 506          a type change.  If the old symbol is a defined symbol, a type
 507          change warning may still be appropriate.  */
 508
 509       if (h->root.type == bfd_link_hash_common)
 510         *type_change_ok = true;
 511     }
 512
 513   /* Handle the special case of an old common symbol merging with a
 514      new symbol which looks like a common symbol in a shared object.
 515      We change *PSEC and *PVALUE to make the new symbol look like a
 516      common symbol, and let _bfd_generic_link_add_one_symbol will do
 517      the right thing.  */
 518
 519   if (newdyncommon
 520       && h->root.type == bfd_link_hash_common)
 521     {
 522       *override = true;
 523       newdef = false;
 524       newdyncommon = false;
 525       *pvalue = sym->st_size;
 526       *psec = sec = bfd_com_section_ptr;
 527       *size_change_ok = true;
 528     }
 529
 530   /* If the old symbol is from a dynamic object, and the new symbol is
 531      a definition which is not from a dynamic object, then the new
 532      symbol overrides the old symbol.  Symbols from regular files
 533      always take precedence over symbols from dynamic objects, even if
 534      they are defined after the dynamic object in the link.
 535
 536      As above, we again permit a common symbol in a regular object to
 537      override a definition in a shared object if the shared object
 538      symbol is a function or is weak.  */
 539
 540   if (! newdyn
 541       && (newdef
 542           || (bfd_is_com_section (sec)
 543               && (h->root.type == bfd_link_hash_defweak
 544                   || h->type == STT_FUNC)))
 545       && olddyn
 546       && olddef
 547       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
 548     {
 549       /* Change the hash table entry to undefined, and let
 550          _bfd_generic_link_add_one_symbol do the right thing with the
 551          new definition.  */
 552
 553       h->root.type = bfd_link_hash_undefined;
 554       h->root.u.undef.abfd = h->root.u.def.section->owner;
 555       *size_change_ok = true;
 556
 557       olddef = false;
 558       olddyncommon = false;
 559
 560       /* We again permit a type change when a common symbol may be
 561          overriding a function.  */
 562
 563       if (bfd_is_com_section (sec))
 564         *type_change_ok = true;
 565
 566       /* This union may have been set to be non-NULL when this symbol
 567          was seen in a dynamic object.  We must force the union to be
 568          NULL, so that it is correct for a regular symbol.  */
 569
 570       h->verinfo.vertree = NULL;
 571
 572       /* In this special case, if H is the target of an indirection,
 573          we want the caller to frob with H rather than with the
 574          indirect symbol.  That will permit the caller to redefine the
 575          target of the indirection, rather than the indirect symbol
 576          itself.  FIXME: This will break the -y option if we store a
 577          symbol with a different name.  */
 578       *sym_hash = h;
 579     }
 580
 581   /* Handle the special case of a new common symbol merging with an
 582      old symbol that looks like it might be a common symbol defined in
 583      a shared object.  Note that we have already handled the case in
 584      which a new common symbol should simply override the definition
 585      in the shared library.  */
 586
 587   if (! newdyn
 588       && bfd_is_com_section (sec)
 589       && olddyncommon)
 590     {
 591       /* It would be best if we could set the hash table entry to a
 592          common symbol, but we don't know what to use for the section
 593          or the alignment.  */
 594       if (! ((*info->callbacks->multiple_common)
 595              (info, h->root.root.string, oldbfd, bfd_link_hash_common,
 596               h->size, abfd, bfd_link_hash_common, sym->st_size)))
 597         return false;
 598
 599       /* If the predumed common symbol in the dynamic object is
 600          larger, pretend that the new symbol has its size.  */
 601
 602       if (h->size > *pvalue)
 603         *pvalue = h->size;
 604
 605       /* FIXME: We no longer know the alignment required by the symbol
 606          in the dynamic object, so we just wind up using the one from
 607          the regular object.  */
 608
 609       olddef = false;
 610       olddyncommon = false;
 611
 612       h->root.type = bfd_link_hash_undefined;
 613       h->root.u.undef.abfd = h->root.u.def.section->owner;
 614
 615       *size_change_ok = true;
 616       *type_change_ok = true;
 617
 618       h->verinfo.vertree = NULL;
 619     }
 620
 621   return true;
 622 }
 623
 624 /* Add symbols from an ELF object file to the linker hash table.  */
 625
 626 static boolean
 627 elf_link_add_object_symbols (abfd, info)
 628      bfd *abfd;
 629      struct bfd_link_info *info;
 630 {
 631   boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
 632                                       const Elf_Internal_Sym *,
 633                                       const char **, flagword *,
 634                                       asection **, bfd_vma *));
 635   boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
 636                                    asection *, const Elf_Internal_Rela *));
 637   boolean collect;
 638   Elf_Internal_Shdr *hdr;
 639   size_t symcount;
 640   size_t extsymcount;
 641   size_t extsymoff;
 642   Elf_External_Sym *buf = NULL;
 643   struct elf_link_hash_entry **sym_hash;
 644   boolean dynamic;
 645   bfd_byte *dynver = NULL;
 646   Elf_External_Versym *extversym = NULL;
 647   Elf_External_Versym *ever;
 648   Elf_External_Dyn *dynbuf = NULL;
 649   struct elf_link_hash_entry *weaks;
 650   Elf_External_Sym *esym;
 651   Elf_External_Sym *esymend;
 652
 653   add_symbol_hook = get_elf_backend_data (abfd)->elf_add_symbol_hook;
 654   collect = get_elf_backend_data (abfd)->collect;
 655
 656   if ((abfd->flags & DYNAMIC) == 0)
 657     dynamic = false;
 658   else
 659     {
 660       dynamic = true;
 661
 662       /* You can't use -r against a dynamic object.  Also, there's no
 663          hope of using a dynamic object which does not exactly match
 664          the format of the output file.  */
 665       if (info->relocateable || info->hash->creator != abfd->xvec)
 666         {
 667           bfd_set_error (bfd_error_invalid_operation);
 668           goto error_return;
 669         }
 670     }
 671
 672   /* As a GNU extension, any input sections which are named
 673      .gnu.warning.SYMBOL are treated as warning symbols for the given
 674      symbol.  This differs from .gnu.warning sections, which generate
 675      warnings when they are included in an output file.  */
 676   if (! info->shared)
 677     {
 678       asection *s;
 679
 680       for (s = abfd->sections; s != NULL; s = s->next)
 681         {
 682           const char *name;
 683
 684           name = bfd_get_section_name (abfd, s);
 685           if (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
 686             {
 687               char *msg;
 688               bfd_size_type sz;
 689
 690               name += sizeof ".gnu.warning." - 1;
 691
 692               /* If this is a shared object, then look up the symbol
 693                  in the hash table.  If it is there, and it is already
 694                  been defined, then we will not be using the entry
 695                  from this shared object, so we don't need to warn.
 696                  FIXME: If we see the definition in a regular object
 697                  later on, we will warn, but we shouldn't.  The only
 698                  fix is to keep track of what warnings we are supposed
 699                  to emit, and then handle them all at the end of the
 700                  link.  */
 701               if (dynamic && abfd->xvec == info->hash->creator)
 702                 {
 703                   struct elf_link_hash_entry *h;
 704
 705                   h = elf_link_hash_lookup (elf_hash_table (info), name,
 706                                             false, false, true);
 707
 708                   /* FIXME: What about bfd_link_hash_common?  */
 709                   if (h != NULL
 710                       && (h->root.type == bfd_link_hash_defined
 711                           || h->root.type == bfd_link_hash_defweak))
 712                     {
 713                       /* We don't want to issue this warning.  Clobber
 714                          the section size so that the warning does not
 715                          get copied into the output file.  */
 716                       s->_raw_size = 0;
 717                       continue;
 718                     }
 719                 }
 720
 721               sz = bfd_section_size (abfd, s);
 722               msg = (char *) bfd_alloc (abfd, sz);
 723               if (msg == NULL)
 724                 goto error_return;
 725
 726               if (! bfd_get_section_contents (abfd, s, msg, (file_ptr) 0, sz))
 727                 goto error_return;
 728
 729               if (! (_bfd_generic_link_add_one_symbol
 730                      (info, abfd, name, BSF_WARNING, s, (bfd_vma) 0, msg,
 731                       false, collect, (struct bfd_link_hash_entry **) NULL)))
 732                 goto error_return;
 733
 734               if (! info->relocateable)
 735                 {
 736                   /* Clobber the section size so that the warning does
 737                      not get copied into the output file.  */
 738                   s->_raw_size = 0;
 739                 }
 740             }
 741         }
 742     }
 743
 744   /* If this is a dynamic object, we always link against the .dynsym
 745      symbol table, not the .symtab symbol table.  The dynamic linker
 746      will only see the .dynsym symbol table, so there is no reason to
 747      look at .symtab for a dynamic object.  */
 748
 749   if (! dynamic || elf_dynsymtab (abfd) == 0)
 750     hdr = &elf_tdata (abfd)->symtab_hdr;
 751   else
 752     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
 753
 754   if (dynamic)
 755     {
 756       /* Read in any version definitions.  */
 757
 758       if (! _bfd_elf_slurp_version_tables (abfd))
 759         goto error_return;
 760
 761       /* Read in the symbol versions, but don't bother to convert them
 762          to internal format.  */
 763       if (elf_dynversym (abfd) != 0)
 764         {
 765           Elf_Internal_Shdr *versymhdr;
 766
 767           versymhdr = &elf_tdata (abfd)->dynversym_hdr;
 768           extversym = (Elf_External_Versym *) bfd_malloc (hdr->sh_size);
 769           if (extversym == NULL)
 770             goto error_return;
 771           if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
 772               || (bfd_read ((PTR) extversym, 1, versymhdr->sh_size, abfd)
 773                   != versymhdr->sh_size))
 774             goto error_return;
 775         }
 776     }
 777
 778   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
 779
 780   /* The sh_info field of the symtab header tells us where the
 781      external symbols start.  We don't care about the local symbols at
 782      this point.  */
 783   if (elf_bad_symtab (abfd))
 784     {
 785       extsymcount = symcount;
 786       extsymoff = 0;
 787     }
 788   else
 789     {
 790       extsymcount = symcount - hdr->sh_info;
 791       extsymoff = hdr->sh_info;
 792     }
 793
 794   buf = ((Elf_External_Sym *)
 795          bfd_malloc (extsymcount * sizeof (Elf_External_Sym)));
 796   if (buf == NULL && extsymcount != 0)
 797     goto error_return;
 798
 799   /* We store a pointer to the hash table entry for each external
 800      symbol.  */
 801   sym_hash = ((struct elf_link_hash_entry **)
 802               bfd_alloc (abfd,
 803                          extsymcount * sizeof (struct elf_link_hash_entry *)));
 804   if (sym_hash == NULL)
 805     goto error_return;
 806   elf_sym_hashes (abfd) = sym_hash;
 807
 808   if (! dynamic)
 809     {
 810       /* If we are creating a shared library, create all the dynamic
 811          sections immediately.  We need to attach them to something,
 812          so we attach them to this BFD, provided it is the right
 813          format.  FIXME: If there are no input BFD's of the same
 814          format as the output, we can't make a shared library.  */
 815       if (info->shared
 816           && ! elf_hash_table (info)->dynamic_sections_created
 817           && abfd->xvec == info->hash->creator)
 818         {
 819           if (! elf_link_create_dynamic_sections (abfd, info))
 820             goto error_return;
 821         }
 822     }
 823   else
 824     {
 825       asection *s;
 826       boolean add_needed;
 827       const char *name;
 828       bfd_size_type oldsize;
 829       bfd_size_type strindex;
 830
 831       /* Find the name to use in a DT_NEEDED entry that refers to this
 832          object.  If the object has a DT_SONAME entry, we use it.
 833          Otherwise, if the generic linker stuck something in
 834          elf_dt_name, we use that.  Otherwise, we just use the file
 835          name.  If the generic linker put a null string into
 836          elf_dt_name, we don't make a DT_NEEDED entry at all, even if
 837          there is a DT_SONAME entry.  */
 838       add_needed = true;
 839       name = bfd_get_filename (abfd);
 840       if (elf_dt_name (abfd) != NULL)
 841         {
 842           name = elf_dt_name (abfd);
 843           if (*name == '\0')
 844             add_needed = false;
 845         }
 846       s = bfd_get_section_by_name (abfd, ".dynamic");
 847       if (s != NULL)
 848         {
 849           Elf_External_Dyn *extdyn;
 850           Elf_External_Dyn *extdynend;
 851           int elfsec;
 852           unsigned long link;
 853
 854           dynbuf = (Elf_External_Dyn *) bfd_malloc ((size_t) s->_raw_size);
 855           if (dynbuf == NULL)
 856             goto error_return;
 857
 858           if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
 859                                           (file_ptr) 0, s->_raw_size))
 860             goto error_return;
 861
 862           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
 863           if (elfsec == -1)
 864             goto error_return;
 865           link = elf_elfsections (abfd)[elfsec]->sh_link;
 866
 867           extdyn = dynbuf;
 868           extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
 869           for (; extdyn < extdynend; extdyn++)
 870             {
 871               Elf_Internal_Dyn dyn;
 872
 873               elf_swap_dyn_in (abfd, extdyn, &dyn);
 874               if (dyn.d_tag == DT_SONAME)
 875                 {
 876                   name = bfd_elf_string_from_elf_section (abfd, link,
 877                                                           dyn.d_un.d_val);
 878                   if (name == NULL)
 879                     goto error_return;
 880                 }
 881               if (dyn.d_tag == DT_NEEDED)
 882                 {
 883                   struct bfd_link_needed_list *n, **pn;
 884                   char *fnm, *anm;
 885
 886                   n = ((struct bfd_link_needed_list *)
 887                        bfd_alloc (abfd, sizeof (struct bfd_link_needed_list)));
 888                   fnm = bfd_elf_string_from_elf_section (abfd, link,
 889                                                          dyn.d_un.d_val);
 890                   if (n == NULL || fnm == NULL)
 891                     goto error_return;
 892                   anm = bfd_alloc (abfd, strlen (fnm) + 1);
 893                   if (anm == NULL)
 894                     goto error_return;
 895                   strcpy (anm, fnm);
 896                   n->name = anm;
 897                   n->by = abfd;
 898                   n->next = NULL;
 899                   for (pn = &elf_hash_table (info)->needed;
 900                        *pn != NULL;
 901                        pn = &(*pn)->next)
 902                     ;
 903                   *pn = n;
 904                 }
 905             }
 906
 907           free (dynbuf);
 908           dynbuf = NULL;
 909         }
 910
 911       /* We do not want to include any of the sections in a dynamic
 912          object in the output file.  We hack by simply clobbering the
 913          list of sections in the BFD.  This could be handled more
 914          cleanly by, say, a new section flag; the existing
 915          SEC_NEVER_LOAD flag is not the one we want, because that one
 916          still implies that the section takes up space in the output
 917          file.  */
 918       abfd->sections = NULL;
 919       abfd->section_count = 0;
 920
 921       /* If this is the first dynamic object found in the link, create
 922          the special sections required for dynamic linking.  */
 923       if (! elf_hash_table (info)->dynamic_sections_created)
 924         {
 925           if (! elf_link_create_dynamic_sections (abfd, info))
 926             goto error_return;
 927         }
 928
 929       if (add_needed)
 930         {
 931           /* Add a DT_NEEDED entry for this dynamic object.  */
 932           oldsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
 933           strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr, name,
 934                                          true, false);
 935           if (strindex == (bfd_size_type) -1)
 936             goto error_return;
 937
 938           if (oldsize == _bfd_stringtab_size (elf_hash_table (info)->dynstr))
 939             {
 940               asection *sdyn;
 941               Elf_External_Dyn *dyncon, *dynconend;
 942
 943               /* The hash table size did not change, which means that
 944                  the dynamic object name was already entered.  If we
 945                  have already included this dynamic object in the
 946                  link, just ignore it.  There is no reason to include
 947                  a particular dynamic object more than once.  */
 948               sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
 949                                               ".dynamic");
 950               BFD_ASSERT (sdyn != NULL);
 951
 952               dyncon = (Elf_External_Dyn *) sdyn->contents;
 953               dynconend = (Elf_External_Dyn *) (sdyn->contents +
 954                                                 sdyn->_raw_size);
 955               for (; dyncon < dynconend; dyncon++)
 956                 {
 957                   Elf_Internal_Dyn dyn;
 958
 959                   elf_swap_dyn_in (elf_hash_table (info)->dynobj, dyncon,
 960                                    &dyn);
 961                   if (dyn.d_tag == DT_NEEDED
 962                       && dyn.d_un.d_val == strindex)
 963                     {
 964                       if (buf != NULL)
 965                         free (buf);
 966                       if (extversym != NULL)
 967                         free (extversym);
 968                       return true;
 969                     }
 970                 }
 971             }
 972
 973           if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
 974             goto error_return;
 975         }
 976
 977       /* Save the SONAME, if there is one, because sometimes the
 978          linker emulation code will need to know it.  */
 979       if (*name == '\0')
 980         name = bfd_get_filename (abfd);
 981       elf_dt_name (abfd) = name;
 982     }
 983
 984   if (bfd_seek (abfd,
 985                 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
 986                 SEEK_SET) != 0
 987       || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
 988           != extsymcount * sizeof (Elf_External_Sym)))
 989     goto error_return;
 990
 991   weaks = NULL;
 992
 993   ever = extversym != NULL ? extversym + extsymoff : NULL;
 994   esymend = buf + extsymcount;
 995   for (esym = buf;
 996        esym < esymend;
 997        esym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
 998     {
 999       Elf_Internal_Sym sym;
1000       int bind;
1001       bfd_vma value;
1002       asection *sec;
1003       flagword flags;
1004       const char *name;
1005       struct elf_link_hash_entry *h;
1006       boolean definition;
1007       boolean size_change_ok, type_change_ok;
1008       boolean new_weakdef;
1009       unsigned int old_alignment;
1010
1011       elf_swap_symbol_in (abfd, esym, &sym);
1012
1013       flags = BSF_NO_FLAGS;
1014       sec = NULL;
1015       value = sym.st_value;
1016       *sym_hash = NULL;
1017
1018       bind = ELF_ST_BIND (sym.st_info);
1019       if (bind == STB_LOCAL)
1020         {
1021           /* This should be impossible, since ELF requires that all
1022              global symbols follow all local symbols, and that sh_info
1023              point to the first global symbol.  Unfortunatealy, Irix 5
1024              screws this up.  */
1025           continue;
1026         }
1027       else if (bind == STB_GLOBAL)
1028         {
1029           if (sym.st_shndx != SHN_UNDEF
1030               && sym.st_shndx != SHN_COMMON)
1031             flags = BSF_GLOBAL;
1032           else
1033             flags = 0;
1034         }
1035       else if (bind == STB_WEAK)
1036         flags = BSF_WEAK;
1037       else
1038         {
1039           /* Leave it up to the processor backend.  */
1040         }
1041
1042       if (sym.st_shndx == SHN_UNDEF)
1043         sec = bfd_und_section_ptr;
1044       else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
1045         {
1046           sec = section_from_elf_index (abfd, sym.st_shndx);
1047           if (sec == NULL)
1048             sec = bfd_abs_section_ptr;
1049           else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1050             value -= sec->vma;
1051         }
1052       else if (sym.st_shndx == SHN_ABS)
1053         sec = bfd_abs_section_ptr;
1054       else if (sym.st_shndx == SHN_COMMON)
1055         {
1056           sec = bfd_com_section_ptr;
1057           /* What ELF calls the size we call the value.  What ELF
1058              calls the value we call the alignment.  */
1059           value = sym.st_size;
1060         }
1061       else
1062         {
1063           /* Leave it up to the processor backend.  */
1064         }
1065
1066       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
1067       if (name == (const char *) NULL)
1068         goto error_return;
1069
1070       if (add_symbol_hook)
1071         {
1072           if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
1073                                     &value))
1074             goto error_return;
1075
1076           /* The hook function sets the name to NULL if this symbol
1077              should be skipped for some reason.  */
1078           if (name == (const char *) NULL)
1079             continue;
1080         }
1081
1082       /* Sanity check that all possibilities were handled.  */
1083       if (sec == (asection *) NULL)
1084         {
1085           bfd_set_error (bfd_error_bad_value);
1086           goto error_return;
1087         }
1088
1089       if (bfd_is_und_section (sec)
1090           || bfd_is_com_section (sec))
1091         definition = false;
1092       else
1093         definition = true;
1094
1095       size_change_ok = false;
1096       type_change_ok = get_elf_backend_data (abfd)->type_change_ok;
1097       old_alignment = 0;
1098       if (info->hash->creator->flavour == bfd_target_elf_flavour)
1099         {
1100           Elf_Internal_Versym iver;
1101           int vernum;
1102           boolean override;
1103
1104           if (ever != NULL)
1105             {
1106               _bfd_elf_swap_versym_in (abfd, ever, &iver);
1107               vernum = iver.vs_vers & VERSYM_VERSION;
1108
1109               /* If this is a hidden symbol, or if it is not version
1110                  1, we append the version name to the symbol name.
1111                  However, we do not modify a non-hidden absolute
1112                  symbol, because it might be the version symbol
1113                  itself.  FIXME: What if it isn't?  */
1114               if ((iver.vs_vers & VERSYM_HIDDEN) != 0
1115                   || (vernum > 1 && ! bfd_is_abs_section (sec)))
1116                 {
1117                   const char *verstr;
1118                   int namelen, newlen;
1119                   char *newname, *p;
1120
1121                   if (sym.st_shndx != SHN_UNDEF)
1122                     {
1123                       if (vernum > elf_tdata (abfd)->dynverdef_hdr.sh_info)
1124                         {
1125                           (*_bfd_error_handler)
1126                             ("%s: %s: invalid version %d (max %d)",
1127                              abfd->filename, name, vernum,
1128                              elf_tdata (abfd)->dynverdef_hdr.sh_info);
1129                           bfd_set_error (bfd_error_bad_value);
1130                           goto error_return;
1131                         }
1132                       else if (vernum > 1)
1133                         verstr =
1134                           elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1135                       else
1136                         verstr = "";
1137                     }
1138                   else
1139                     {
1140                       /* We cannot simply test for the number of
1141                          entries in the VERNEED section since the
1142                          numbers for the needed versions do not start
1143                          at 0.  */
1144                       Elf_Internal_Verneed *t;
1145
1146                       verstr = NULL;
1147                       for (t = elf_tdata (abfd)->verref;
1148                            t != NULL;
1149                            t = t->vn_nextref)
1150                         {
1151                           Elf_Internal_Vernaux *a;
1152
1153                           for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1154                             {
1155                               if (a->vna_other == vernum)
1156                                 {
1157                                   verstr = a->vna_nodename;
1158                                   break;
1159                                 }
1160                             }
1161                           if (a != NULL)
1162                             break;
1163                         }
1164                       if (verstr == NULL)
1165                         {
1166                           (*_bfd_error_handler)
1167                             ("%s: %s: invalid needed version %d",
1168                              abfd->filename, name, vernum);
1169                           bfd_set_error (bfd_error_bad_value);
1170                           goto error_return;
1171                         }
1172                     }
1173
1174                   namelen = strlen (name);
1175                   newlen = namelen + strlen (verstr) + 2;
1176                   if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
1177                     ++newlen;
1178
1179                   newname = (char *) bfd_alloc (abfd, newlen);
1180                   if (newname == NULL)
1181                     goto error_return;
1182                   strcpy (newname, name);
1183                   p = newname + namelen;
1184                   *p++ = ELF_VER_CHR;
1185                   if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
1186                     *p++ = ELF_VER_CHR;
1187                   strcpy (p, verstr);
1188
1189                   name = newname;
1190                 }
1191             }
1192
1193           if (! elf_merge_symbol (abfd, info, name, &sym, &sec, &value,
1194                                   sym_hash, &override, &type_change_ok,
1195                                   &size_change_ok))
1196             goto error_return;
1197
1198           if (override)
1199             definition = false;
1200
1201           h = *sym_hash;
1202           while (h->root.type == bfd_link_hash_indirect
1203                  || h->root.type == bfd_link_hash_warning)
1204             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1205
1206           /* Remember the old alignment if this is a common symbol, so
1207              that we don't reduce the alignment later on.  We can't
1208              check later, because _bfd_generic_link_add_one_symbol
1209              will set a default for the alignment which we want to
1210              override.  */
1211           if (h->root.type == bfd_link_hash_common)
1212             old_alignment = h->root.u.c.p->alignment_power;
1213
1214           if (elf_tdata (abfd)->verdef != NULL
1215               && ! override
1216               && vernum > 1
1217               && definition)
1218             h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
1219         }
1220
1221       if (! (_bfd_generic_link_add_one_symbol
1222              (info, abfd, name, flags, sec, value, (const char *) NULL,
1223               false, collect, (struct bfd_link_hash_entry **) sym_hash)))
1224         goto error_return;
1225
1226       h = *sym_hash;
1227       while (h->root.type == bfd_link_hash_indirect
1228              || h->root.type == bfd_link_hash_warning)
1229         h = (struct elf_link_hash_entry *) h->root.u.i.link;
1230       *sym_hash = h;
1231
1232       new_weakdef = false;
1233       if (dynamic
1234           && definition
1235           && (flags & BSF_WEAK) != 0
1236           && ELF_ST_TYPE (sym.st_info) != STT_FUNC
1237           && info->hash->creator->flavour == bfd_target_elf_flavour
1238           && h->weakdef == NULL)
1239         {
1240           /* Keep a list of all weak defined non function symbols from
1241              a dynamic object, using the weakdef field.  Later in this
1242              function we will set the weakdef field to the correct
1243              value.  We only put non-function symbols from dynamic
1244              objects on this list, because that happens to be the only
1245              time we need to know the normal symbol corresponding to a
1246              weak symbol, and the information is time consuming to
1247              figure out.  If the weakdef field is not already NULL,
1248              then this symbol was already defined by some previous
1249              dynamic object, and we will be using that previous
1250              definition anyhow.  */
1251
1252           h->weakdef = weaks;
1253           weaks = h;
1254           new_weakdef = true;
1255         }
1256
1257       /* Set the alignment of a common symbol.  */
1258       if (sym.st_shndx == SHN_COMMON
1259           && h->root.type == bfd_link_hash_common)
1260         {
1261           unsigned int align;
1262
1263           align = bfd_log2 (sym.st_value);
1264           if (align > old_alignment)
1265             h->root.u.c.p->alignment_power = align;
1266         }
1267
1268       if (info->hash->creator->flavour == bfd_target_elf_flavour)
1269         {
1270           int old_flags;
1271           boolean dynsym;
1272           int new_flag;
1273
1274           /* Remember the symbol size and type.  */
1275           if (sym.st_size != 0
1276               && (definition || h->size == 0))
1277             {
1278               if (h->size != 0 && h->size != sym.st_size && ! size_change_ok)
1279                 (*_bfd_error_handler)
1280                   ("Warning: size of symbol `%s' changed from %lu to %lu in %s",
1281                    name, (unsigned long) h->size, (unsigned long) sym.st_size,
1282                    bfd_get_filename (abfd));
1283
1284               h->size = sym.st_size;
1285             }
1286
1287           /* If this is a common symbol, then we always want H->SIZE
1288              to be the size of the common symbol.  The code just above
1289              won't fix the size if a common symbol becomes larger.  We
1290              don't warn about a size change here, because that is
1291              covered by --warn-common.  */
1292           if (h->root.type == bfd_link_hash_common)
1293             h->size = h->root.u.c.size;
1294
1295           if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE
1296               && (definition || h->type == STT_NOTYPE))
1297             {
1298               if (h->type != STT_NOTYPE
1299                   && h->type != ELF_ST_TYPE (sym.st_info)
1300                   && ! type_change_ok)
1301                 (*_bfd_error_handler)
1302                   ("Warning: type of symbol `%s' changed from %d to %d in %s",
1303                    name, h->type, ELF_ST_TYPE (sym.st_info),
1304                    bfd_get_filename (abfd));
1305
1306               h->type = ELF_ST_TYPE (sym.st_info);
1307             }
1308
1309           if (sym.st_other != 0
1310               && (definition || h->other == 0))
1311             h->other = sym.st_other;
1312
1313           /* Set a flag in the hash table entry indicating the type of
1314              reference or definition we just found.  Keep a count of
1315              the number of dynamic symbols we find.  A dynamic symbol
1316              is one which is referenced or defined by both a regular
1317              object and a shared object.  */
1318           old_flags = h->elf_link_hash_flags;
1319           dynsym = false;
1320           if (! dynamic)
1321             {
1322               if (! definition)
1323                 new_flag = ELF_LINK_HASH_REF_REGULAR;
1324               else
1325                 new_flag = ELF_LINK_HASH_DEF_REGULAR;
1326               if (info->shared
1327                   || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1328                                    | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
1329                 dynsym = true;
1330             }
1331           else
1332             {
1333               if (! definition)
1334                 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
1335               else
1336                 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
1337               if ((old_flags & (ELF_LINK_HASH_DEF_REGULAR
1338                                 | ELF_LINK_HASH_REF_REGULAR)) != 0
1339                   || (h->weakdef != NULL
1340                       && ! new_weakdef
1341                       && h->weakdef->dynindx != -1))
1342                 dynsym = true;
1343             }
1344
1345           h->elf_link_hash_flags |= new_flag;
1346
1347           /* If this symbol has a version, and it is the default
1348              version, we create an indirect symbol from the default
1349              name to the fully decorated name.  This will cause
1350              external references which do not specify a version to be
1351              bound to this version of the symbol.  */
1352           if (definition)
1353             {
1354               char *p;
1355
1356               p = strchr (name, ELF_VER_CHR);
1357               if (p != NULL && p[1] == ELF_VER_CHR)
1358                 {
1359                   char *shortname;
1360                   struct elf_link_hash_entry *hi;
1361                   boolean override;
1362
1363                   shortname = bfd_hash_allocate (&info->hash->table,
1364                                                  p - name + 1);
1365                   if (shortname == NULL)
1366                     goto error_return;
1367                   strncpy (shortname, name, p - name);
1368                   shortname[p - name] = '\0';
1369
1370                   /* We are going to create a new symbol.  Merge it
1371                      with any existing symbol with this name.  For the
1372                      purposes of the merge, act as though we were
1373                      defining the symbol we just defined, although we
1374                      actually going to define an indirect symbol.  */
1375                   if (! elf_merge_symbol (abfd, info, shortname, &sym, &sec,
1376                                           &value, &hi, &override,
1377                                           &type_change_ok, &size_change_ok))
1378                     goto error_return;
1379
1380                   if (! override)
1381                     {
1382                       if (! (_bfd_generic_link_add_one_symbol
1383                              (info, abfd, shortname, BSF_INDIRECT,
1384                               bfd_ind_section_ptr, (bfd_vma) 0, name, false,
1385                               collect, (struct bfd_link_hash_entry **) &hi)))
1386                         goto error_return;
1387                     }
1388                   else
1389                     {
1390                       /* In this case the symbol named SHORTNAME is
1391                          overriding the indirect symbol we want to
1392                          add.  We were planning on making SHORTNAME an
1393                          indirect symbol referring to NAME.  SHORTNAME
1394                          is the name without a version.  NAME is the
1395                          fully versioned name, and it is the default
1396                          version.
1397
1398                          Overriding means that we already saw a
1399                          definition for the symbol SHORTNAME in a
1400                          regular object, and it is overriding the
1401                          symbol defined in the dynamic object.
1402
1403                          When this happens, we actually want to change
1404                          NAME, the symbol we just added, to refer to
1405                          SHORTNAME.  This will cause references to
1406                          NAME in the shared object to become
1407                          references to SHORTNAME in the regular
1408                          object.  This is what we expect when we
1409                          override a function in a shared object: that
1410                          the references in the shared object will be
1411                          mapped to the definition in the regular
1412                          object.  */
1413
1414                       while (hi->root.type == bfd_link_hash_indirect
1415                              || hi->root.type == bfd_link_hash_warning)
1416                         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1417
1418                       h->root.type = bfd_link_hash_indirect;
1419                       h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1420                       if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
1421                         {
1422                           h->elf_link_hash_flags &=~ ELF_LINK_HASH_DEF_DYNAMIC;
1423                           hi->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
1424                           if (! _bfd_elf_link_record_dynamic_symbol (info, hi))
1425                             goto error_return;
1426                         }
1427
1428                       /* Now set HI to H, so that the following code
1429                          will set the other fields correctly.  */
1430                       hi = h;
1431                     }
1432
1433                   /* If there is a duplicate definition somewhere,
1434                      then HI may not point to an indirect symbol.  We
1435                      will have reported an error to the user in that
1436                      case.  */
1437
1438                   if (hi->root.type == bfd_link_hash_indirect)
1439                     {
1440                       struct elf_link_hash_entry *ht;
1441
1442                       /* If the symbol became indirect, then we assume
1443                          that we have not seen a definition before.  */
1444                       BFD_ASSERT ((hi->elf_link_hash_flags
1445                                    & (ELF_LINK_HASH_DEF_DYNAMIC
1446                                       | ELF_LINK_HASH_DEF_REGULAR))
1447                                   == 0);
1448
1449                       ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1450
1451                       /* Copy down any references that we may have
1452                          already seen to the symbol which just became
1453                          indirect.  */
1454                       ht->elf_link_hash_flags |=
1455                         (hi->elf_link_hash_flags
1456                          & (ELF_LINK_HASH_REF_DYNAMIC
1457                             | ELF_LINK_HASH_REF_REGULAR));
1458
1459                       /* Copy over the global table offset entry.
1460                          This may have been already set up by a
1461                          check_relocs routine.  */
1462                       if (ht->got_offset == (bfd_vma) -1)
1463                         {
1464                           ht->got_offset = hi->got_offset;
1465                           hi->got_offset = (bfd_vma) -1;
1466                         }
1467                       BFD_ASSERT (hi->got_offset == (bfd_vma) -1);
1468
1469                       if (ht->dynindx == -1)
1470                         {
1471                           ht->dynindx = hi->dynindx;
1472                           ht->dynstr_index = hi->dynstr_index;
1473                           hi->dynindx = -1;
1474                           hi->dynstr_index = 0;
1475                         }
1476                       BFD_ASSERT (hi->dynindx == -1);
1477
1478                       /* FIXME: There may be other information to copy
1479                          over for particular targets.  */
1480
1481                       /* See if the new flags lead us to realize that
1482                          the symbol must be dynamic.  */
1483                       if (! dynsym)
1484                         {
1485                           if (! dynamic)
1486                             {
1487                               if (info->shared
1488                                   || ((hi->elf_link_hash_flags
1489                                        & ELF_LINK_HASH_REF_DYNAMIC)
1490                                       != 0))
1491                                 dynsym = true;
1492                             }
1493                           else
1494                             {
1495                               if ((hi->elf_link_hash_flags
1496                                    & ELF_LINK_HASH_REF_REGULAR) != 0)
1497                                 dynsym = true;
1498                             }
1499                         }
1500                     }
1501
1502                   /* We also need to define an indirection from the
1503                      nondefault version of the symbol.  */
1504
1505                   shortname = bfd_hash_allocate (&info->hash->table,
1506                                                  strlen (name));
1507                   if (shortname == NULL)
1508                     goto error_return;
1509                   strncpy (shortname, name, p - name);
1510                   strcpy (shortname + (p - name), p + 1);
1511
1512                   /* Once again, merge with any existing symbol.  */
1513                   if (! elf_merge_symbol (abfd, info, shortname, &sym, &sec,
1514                                           &value, &hi, &override,
1515                                           &type_change_ok, &size_change_ok))
1516                     goto error_return;
1517
1518                   if (override)
1519                     {
1520                       /* Here SHORTNAME is a versioned name, so we
1521                          don't expect to see the type of override we
1522                          do in the case above.  */
1523                       (*_bfd_error_handler)
1524                         ("%s: warning: unexpected redefinition of `%s'",
1525                          bfd_get_filename (abfd), shortname);
1526                     }
1527                   else
1528                     {
1529                       if (! (_bfd_generic_link_add_one_symbol
1530                              (info, abfd, shortname, BSF_INDIRECT,
1531                               bfd_ind_section_ptr, (bfd_vma) 0, name, false,
1532                               collect, (struct bfd_link_hash_entry **) &hi)))
1533                         goto error_return;
1534
1535                       /* If there is a duplicate definition somewhere,
1536                          then HI may not point to an indirect symbol.
1537                          We will have reported an error to the user in
1538                          that case.  */
1539
1540                       if (hi->root.type == bfd_link_hash_indirect)
1541                         {
1542                           /* If the symbol became indirect, then we
1543                              assume that we have not seen a definition
1544                              before.  */
1545                           BFD_ASSERT ((hi->elf_link_hash_flags
1546                                        & (ELF_LINK_HASH_DEF_DYNAMIC
1547                                           | ELF_LINK_HASH_DEF_REGULAR))
1548                                       == 0);
1549
1550                           /* Copy down any references that we may have
1551                              already seen to the symbol which just
1552                              became indirect.  */
1553                           h->elf_link_hash_flags |=
1554                             (hi->elf_link_hash_flags
1555                              & (ELF_LINK_HASH_REF_DYNAMIC
1556                                 | ELF_LINK_HASH_REF_REGULAR));
1557
1558                           /* Copy over the global table offset entry.
1559                              This may have been already set up by a
1560                              check_relocs routine.  */
1561                           if (h->got_offset == (bfd_vma) -1)
1562                             {
1563                               h->got_offset = hi->got_offset;
1564                               hi->got_offset = (bfd_vma) -1;
1565                             }
1566                           BFD_ASSERT (hi->got_offset == (bfd_vma) -1);
1567
1568                           if (h->dynindx == -1)
1569                             {
1570                               h->dynindx = hi->dynindx;
1571                               h->dynstr_index = hi->dynstr_index;
1572                               hi->dynindx = -1;
1573                               hi->dynstr_index = 0;
1574                             }
1575                           BFD_ASSERT (hi->dynindx == -1);
1576
1577                           /* FIXME: There may be other information to
1578                              copy over for particular targets.  */
1579
1580                           /* See if the new flags lead us to realize
1581                              that the symbol must be dynamic.  */
1582                           if (! dynsym)
1583                             {
1584                               if (! dynamic)
1585                                 {
1586                                   if (info->shared
1587                                       || ((hi->elf_link_hash_flags
1588                                            & ELF_LINK_HASH_REF_DYNAMIC)
1589                                           != 0))
1590                                     dynsym = true;
1591                                 }
1592                               else
1593                                 {
1594                                   if ((hi->elf_link_hash_flags
1595                                        & ELF_LINK_HASH_REF_REGULAR) != 0)
1596                                     dynsym = true;
1597                                 }
1598                             }
1599                         }
1600                     }
1601                 }
1602             }
1603
1604           if (dynsym && h->dynindx == -1)
1605             {
1606               if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1607                 goto error_return;
1608               if (h->weakdef != NULL
1609                   && ! new_weakdef
1610                   && h->weakdef->dynindx == -1)
1611                 {
1612                   if (! _bfd_elf_link_record_dynamic_symbol (info,
1613                                                              h->weakdef))
1614                     goto error_return;
1615                 }
1616             }
1617         }
1618     }
1619
1620   /* Now set the weakdefs field correctly for all the weak defined
1621      symbols we found.  The only way to do this is to search all the
1622      symbols.  Since we only need the information for non functions in
1623      dynamic objects, that's the only time we actually put anything on
1624      the list WEAKS.  We need this information so that if a regular
1625      object refers to a symbol defined weakly in a dynamic object, the
1626      real symbol in the dynamic object is also put in the dynamic
1627      symbols; we also must arrange for both symbols to point to the
1628      same memory location.  We could handle the general case of symbol
1629      aliasing, but a general symbol alias can only be generated in
1630      assembler code, handling it correctly would be very time
1631      consuming, and other ELF linkers don't handle general aliasing
1632      either.  */
1633   while (weaks != NULL)
1634     {
1635       struct elf_link_hash_entry *hlook;
1636       asection *slook;
1637       bfd_vma vlook;
1638       struct elf_link_hash_entry **hpp;
1639       struct elf_link_hash_entry **hppend;
1640
1641       hlook = weaks;
1642       weaks = hlook->weakdef;
1643       hlook->weakdef = NULL;
1644
1645       BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
1646                   || hlook->root.type == bfd_link_hash_defweak
1647                   || hlook->root.type == bfd_link_hash_common
1648                   || hlook->root.type == bfd_link_hash_indirect);
1649       slook = hlook->root.u.def.section;
1650       vlook = hlook->root.u.def.value;
1651
1652       hpp = elf_sym_hashes (abfd);
1653       hppend = hpp + extsymcount;
1654       for (; hpp < hppend; hpp++)
1655         {
1656           struct elf_link_hash_entry *h;
1657
1658           h = *hpp;
1659           if (h != NULL && h != hlook
1660               && h->root.type == bfd_link_hash_defined
1661               && h->root.u.def.section == slook
1662               && h->root.u.def.value == vlook)
1663             {
1664               hlook->weakdef = h;
1665
1666               /* If the weak definition is in the list of dynamic
1667                  symbols, make sure the real definition is put there
1668                  as well.  */
1669               if (hlook->dynindx != -1
1670                   && h->dynindx == -1)
1671                 {
1672                   if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1673                     goto error_return;
1674                 }
1675
1676               /* If the real definition is in the list of dynamic
1677                  symbols, make sure the weak definition is put there
1678                  as well.  If we don't do this, then the dynamic
1679                  loader might not merge the entries for the real
1680                  definition and the weak definition.  */
1681               if (h->dynindx != -1
1682                   && hlook->dynindx == -1)
1683                 {
1684                   if (! _bfd_elf_link_record_dynamic_symbol (info, hlook))
1685                     goto error_return;
1686                 }
1687
1688               break;
1689             }
1690         }
1691     }
1692
1693   if (buf != NULL)
1694     {
1695       free (buf);
1696       buf = NULL;
1697     }
1698
1699   if (extversym != NULL)
1700     {
1701       free (extversym);
1702       extversym = NULL;
1703     }
1704
1705   /* If this object is the same format as the output object, and it is
1706      not a shared library, then let the backend look through the
1707      relocs.
1708
1709      This is required to build global offset table entries and to
1710      arrange for dynamic relocs.  It is not required for the
1711      particular common case of linking non PIC code, even when linking
1712      against shared libraries, but unfortunately there is no way of
1713      knowing whether an object file has been compiled PIC or not.
1714      Looking through the relocs is not particularly time consuming.
1715      The problem is that we must either (1) keep the relocs in memory,
1716      which causes the linker to require additional runtime memory or
1717      (2) read the relocs twice from the input file, which wastes time.
1718      This would be a good case for using mmap.
1719
1720      I have no idea how to handle linking PIC code into a file of a
1721      different format.  It probably can't be done.  */
1722   check_relocs = get_elf_backend_data (abfd)->check_relocs;
1723   if (! dynamic
1724       && abfd->xvec == info->hash->creator
1725       && check_relocs != NULL)
1726     {
1727       asection *o;
1728
1729       for (o = abfd->sections; o != NULL; o = o->next)
1730         {
1731           Elf_Internal_Rela *internal_relocs;
1732           boolean ok;
1733
1734           if ((o->flags & SEC_RELOC) == 0
1735               || o->reloc_count == 0
1736               || ((info->strip == strip_all || info->strip == strip_debugger)
1737                   && (o->flags & SEC_DEBUGGING) != 0)
1738               || bfd_is_abs_section (o->output_section))
1739             continue;
1740
1741           internal_relocs = (NAME(_bfd_elf,link_read_relocs)
1742                              (abfd, o, (PTR) NULL,
1743                               (Elf_Internal_Rela *) NULL,
1744                               info->keep_memory));
1745           if (internal_relocs == NULL)
1746             goto error_return;
1747
1748           ok = (*check_relocs) (abfd, info, o, internal_relocs);
1749
1750           if (! info->keep_memory)
1751             free (internal_relocs);
1752
1753           if (! ok)
1754             goto error_return;
1755         }
1756     }
1757
1758   /* If this is a non-traditional, non-relocateable link, try to
1759      optimize the handling of the .stab/.stabstr sections.  */
1760   if (! dynamic
1761       && ! info->relocateable
1762       && ! info->traditional_format
1763       && info->hash->creator->flavour == bfd_target_elf_flavour
1764       && (info->strip != strip_all && info->strip != strip_debugger))
1765     {
1766       asection *stab, *stabstr;
1767
1768       stab = bfd_get_section_by_name (abfd, ".stab");
1769       if (stab != NULL)
1770         {
1771           stabstr = bfd_get_section_by_name (abfd, ".stabstr");
1772
1773           if (stabstr != NULL)
1774             {
1775               struct bfd_elf_section_data *secdata;
1776
1777               secdata = elf_section_data (stab);
1778               if (! _bfd_link_section_stabs (abfd,
1779                                              &elf_hash_table (info)->stab_info,
1780                                              stab, stabstr,
1781                                              &secdata->stab_info))
1782                 goto error_return;
1783             }
1784         }
1785     }
1786
1787   return true;
1788
1789  error_return:
1790   if (buf != NULL)
1791     free (buf);
1792   if (dynbuf != NULL)
1793     free (dynbuf);
1794   if (dynver != NULL)
1795     free (dynver);
1796   if (extversym != NULL)
1797     free (extversym);
1798   return false;
1799 }
1800
1801 /* Create some sections which will be filled in with dynamic linking
1802    information.  ABFD is an input file which requires dynamic sections
1803    to be created.  The dynamic sections take up virtual memory space
1804    when the final executable is run, so we need to create them before
1805    addresses are assigned to the output sections.  We work out the
1806    actual contents and size of these sections later.  */
1807
1808 boolean
1809 elf_link_create_dynamic_sections (abfd, info)
1810      bfd *abfd;
1811      struct bfd_link_info *info;
1812 {
1813   flagword flags;
1814   register asection *s;
1815   struct elf_link_hash_entry *h;
1816   struct elf_backend_data *bed;
1817
1818   if (elf_hash_table (info)->dynamic_sections_created)
1819     return true;
1820
1821   /* Make sure that all dynamic sections use the same input BFD.  */
1822   if (elf_hash_table (info)->dynobj == NULL)
1823     elf_hash_table (info)->dynobj = abfd;
1824   else
1825     abfd = elf_hash_table (info)->dynobj;
1826
1827   /* Note that we set the SEC_IN_MEMORY flag for all of these
1828      sections.  */
1829   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1830            | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1831
1832   /* A dynamically linked executable has a .interp section, but a
1833      shared library does not.  */
1834   if (! info->shared)
1835     {
1836       s = bfd_make_section (abfd, ".interp");
1837       if (s == NULL
1838           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1839         return false;
1840     }
1841
1842   /* Create sections to hold version informations.  These are removed
1843      if they are not needed.  */
1844   s = bfd_make_section (abfd, ".gnu.version_d");
1845   if (s == NULL
1846       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1847       || ! bfd_set_section_alignment (abfd, s, 2))
1848     return false;
1849
1850   s = bfd_make_section (abfd, ".gnu.version");
1851   if (s == NULL
1852       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1853       || ! bfd_set_section_alignment (abfd, s, 1))
1854     return false;
1855
1856   s = bfd_make_section (abfd, ".gnu.version_r");
1857   if (s == NULL
1858       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1859       || ! bfd_set_section_alignment (abfd, s, 2))
1860     return false;
1861
1862   s = bfd_make_section (abfd, ".dynsym");
1863   if (s == NULL
1864       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1865       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1866     return false;
1867
1868   s = bfd_make_section (abfd, ".dynstr");
1869   if (s == NULL
1870       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
1871     return false;
1872
1873   /* Create a strtab to hold the dynamic symbol names.  */
1874   if (elf_hash_table (info)->dynstr == NULL)
1875     {
1876       elf_hash_table (info)->dynstr = elf_stringtab_init ();
1877       if (elf_hash_table (info)->dynstr == NULL)
1878         return false;
1879     }
1880
1881   s = bfd_make_section (abfd, ".dynamic");
1882   if (s == NULL
1883       || ! bfd_set_section_flags (abfd, s, flags)
1884       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1885     return false;
1886
1887   /* The special symbol _DYNAMIC is always set to the start of the
1888      .dynamic section.  This call occurs before we have processed the
1889      symbols for any dynamic object, so we don't have to worry about
1890      overriding a dynamic definition.  We could set _DYNAMIC in a
1891      linker script, but we only want to define it if we are, in fact,
1892      creating a .dynamic section.  We don't want to define it if there
1893      is no .dynamic section, since on some ELF platforms the start up
1894      code examines it to decide how to initialize the process.  */
1895   h = NULL;
1896   if (! (_bfd_generic_link_add_one_symbol
1897          (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
1898           (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
1899           (struct bfd_link_hash_entry **) &h)))
1900     return false;
1901   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1902   h->type = STT_OBJECT;
1903
1904   if (info->shared
1905       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1906     return false;
1907
1908   s = bfd_make_section (abfd, ".hash");
1909   if (s == NULL
1910       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1911       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1912     return false;
1913
1914   /* Let the backend create the rest of the sections.  This lets the
1915      backend set the right flags.  The backend will normally create
1916      the .got and .plt sections.  */
1917   bed = get_elf_backend_data (abfd);
1918   if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
1919     return false;
1920
1921   elf_hash_table (info)->dynamic_sections_created = true;
1922
1923   return true;
1924 }
1925
1926 /* Add an entry to the .dynamic table.  */
1927
1928 boolean
1929 elf_add_dynamic_entry (info, tag, val)
1930      struct bfd_link_info *info;
1931      bfd_vma tag;
1932      bfd_vma val;
1933 {
1934   Elf_Internal_Dyn dyn;
1935   bfd *dynobj;
1936   asection *s;
1937   size_t newsize;
1938   bfd_byte *newcontents;
1939
1940   dynobj = elf_hash_table (info)->dynobj;
1941
1942   s = bfd_get_section_by_name (dynobj, ".dynamic");
1943   BFD_ASSERT (s != NULL);
1944
1945   newsize = s->_raw_size + sizeof (Elf_External_Dyn);
1946   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
1947   if (newcontents == NULL)
1948     return false;
1949
1950   dyn.d_tag = tag;
1951   dyn.d_un.d_val = val;
1952   elf_swap_dyn_out (dynobj, &dyn,
1953                     (Elf_External_Dyn *) (newcontents + s->_raw_size));
1954
1955   s->_raw_size = newsize;
1956   s->contents = newcontents;
1957
1958   return true;
1959 }
1960 \f
1961
1962 /* Read and swap the relocs for a section.  They may have been cached.
1963    If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1964    they are used as buffers to read into.  They are known to be large
1965    enough.  If the INTERNAL_RELOCS relocs argument is NULL, the return
1966    value is allocated using either malloc or bfd_alloc, according to
1967    the KEEP_MEMORY argument.  */
1968
1969 Elf_Internal_Rela *
1970 NAME(_bfd_elf,link_read_relocs) (abfd, o, external_relocs, internal_relocs,
1971                                  keep_memory)
1972      bfd *abfd;
1973      asection *o;
1974      PTR external_relocs;
1975      Elf_Internal_Rela *internal_relocs;
1976      boolean keep_memory;
1977 {
1978   Elf_Internal_Shdr *rel_hdr;
1979   PTR alloc1 = NULL;
1980   Elf_Internal_Rela *alloc2 = NULL;
1981
1982   if (elf_section_data (o)->relocs != NULL)
1983     return elf_section_data (o)->relocs;
1984
1985   if (o->reloc_count == 0)
1986     return NULL;
1987
1988   rel_hdr = &elf_section_data (o)->rel_hdr;
1989
1990   if (internal_relocs == NULL)
1991     {
1992       size_t size;
1993
1994       size = o->reloc_count * sizeof (Elf_Internal_Rela);
1995       if (keep_memory)
1996         internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
1997       else
1998         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
1999       if (internal_relocs == NULL)
2000         goto error_return;
2001     }
2002
2003   if (external_relocs == NULL)
2004     {
2005       alloc1 = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
2006       if (alloc1 == NULL)
2007         goto error_return;
2008       external_relocs = alloc1;
2009     }
2010
2011   if ((bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0)
2012       || (bfd_read (external_relocs, 1, rel_hdr->sh_size, abfd)
2013           != rel_hdr->sh_size))
2014     goto error_return;
2015
2016   /* Swap in the relocs.  For convenience, we always produce an
2017      Elf_Internal_Rela array; if the relocs are Rel, we set the addend
2018      to 0.  */
2019   if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2020     {
2021       Elf_External_Rel *erel;
2022       Elf_External_Rel *erelend;
2023       Elf_Internal_Rela *irela;
2024
2025       erel = (Elf_External_Rel *) external_relocs;
2026       erelend = erel + o->reloc_count;
2027       irela = internal_relocs;
2028       for (; erel < erelend; erel++, irela++)
2029         {
2030           Elf_Internal_Rel irel;
2031
2032           elf_swap_reloc_in (abfd, erel, &irel);
2033           irela->r_offset = irel.r_offset;
2034           irela->r_info = irel.r_info;
2035           irela->r_addend = 0;
2036         }
2037     }
2038   else
2039     {
2040       Elf_External_Rela *erela;
2041       Elf_External_Rela *erelaend;
2042       Elf_Internal_Rela *irela;
2043
2044       BFD_ASSERT (rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
2045
2046       erela = (Elf_External_Rela *) external_relocs;
2047       erelaend = erela + o->reloc_count;
2048       irela = internal_relocs;
2049       for (; erela < erelaend; erela++, irela++)
2050         elf_swap_reloca_in (abfd, erela, irela);
2051     }
2052
2053   /* Cache the results for next time, if we can.  */
2054   if (keep_memory)
2055     elf_section_data (o)->relocs = internal_relocs;
2056
2057   if (alloc1 != NULL)
2058     free (alloc1);
2059
2060   /* Don't free alloc2, since if it was allocated we are passing it
2061      back (under the name of internal_relocs).  */
2062
2063   return internal_relocs;
2064
2065  error_return:
2066   if (alloc1 != NULL)
2067     free (alloc1);
2068   if (alloc2 != NULL)
2069     free (alloc2);
2070   return NULL;
2071 }
2072 \f
2073
2074 /* Record an assignment to a symbol made by a linker script.  We need
2075    this in case some dynamic object refers to this symbol.  */
2076
2077 /*ARGSUSED*/
2078 boolean
2079 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
2080      bfd *output_bfd;
2081      struct bfd_link_info *info;
2082      const char *name;
2083      boolean provide;
2084 {
2085   struct elf_link_hash_entry *h;
2086
2087   if (info->hash->creator->flavour != bfd_target_elf_flavour)
2088     return true;
2089
2090   h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
2091   if (h == NULL)
2092     return false;
2093
2094   if (h->root.type == bfd_link_hash_new)
2095     h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
2096
2097   /* If this symbol is being provided by the linker script, and it is
2098      currently defined by a dynamic object, but not by a regular
2099      object, then mark it as undefined so that the generic linker will
2100      force the correct value.  */
2101   if (provide
2102       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2103       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2104     h->root.type = bfd_link_hash_undefined;
2105
2106   /* If this symbol is not being provided by the linker script, and it is
2107      currently defined by a dynamic object, but not by a regular object,
2108      then clear out any version information because the symbol will not be
2109      associated with the dynamic object any more.  */
2110   if (!provide
2111       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2112       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2113     h->verinfo.verdef = NULL;
2114
2115   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2116   h->type = STT_OBJECT;
2117
2118   if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
2119                                   | ELF_LINK_HASH_REF_DYNAMIC)) != 0
2120        || info->shared)
2121       && h->dynindx == -1)
2122     {
2123       if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2124         return false;
2125
2126       /* If this is a weak defined symbol, and we know a corresponding
2127          real symbol from the same dynamic object, make sure the real
2128          symbol is also made into a dynamic symbol.  */
2129       if (h->weakdef != NULL
2130           && h->weakdef->dynindx == -1)
2131         {
2132           if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
2133             return false;
2134         }
2135     }
2136
2137   return true;
2138 }
2139 \f
2140 /* This structure is used to pass information to
2141    elf_link_assign_sym_version.  */
2142
2143 struct elf_assign_sym_version_info
2144 {
2145   /* Output BFD.  */
2146   bfd *output_bfd;
2147   /* General link information.  */
2148   struct bfd_link_info *info;
2149   /* Version tree.  */
2150   struct bfd_elf_version_tree *verdefs;
2151   /* Whether we are exporting all dynamic symbols.  */
2152   boolean export_dynamic;
2153   /* Whether we removed any symbols from the dynamic symbol table.  */
2154   boolean removed_dynamic;
2155   /* Whether we had a failure.  */
2156   boolean failed;
2157 };
2158
2159 /* This structure is used to pass information to
2160    elf_link_find_version_dependencies.  */
2161
2162 struct elf_find_verdep_info
2163 {
2164   /* Output BFD.  */
2165   bfd *output_bfd;
2166   /* General link information.  */
2167   struct bfd_link_info *info;
2168   /* The number of dependencies.  */
2169   unsigned int vers;
2170   /* Whether we had a failure.  */
2171   boolean failed;
2172 };
2173
2174 /* Array used to determine the number of hash table buckets to use
2175    based on the number of symbols there are.  If there are fewer than
2176    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
2177    fewer than 37 we use 17 buckets, and so forth.  We never use more
2178    than 32771 buckets.  */
2179
2180 static const size_t elf_buckets[] =
2181 {
2182   1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
2183   16411, 32771, 0
2184 };
2185
2186 /* Set up the sizes and contents of the ELF dynamic sections.  This is
2187    called by the ELF linker emulation before_allocation routine.  We
2188    must set the sizes of the sections before the linker sets the
2189    addresses of the various sections.  */
2190
2191 boolean
2192 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
2193                                      export_dynamic, filter_shlib,
2194                                      auxiliary_filters, info, sinterpptr,
2195                                      verdefs)
2196      bfd *output_bfd;
2197      const char *soname;
2198      const char *rpath;
2199      boolean export_dynamic;
2200      const char *filter_shlib;
2201      const char * const *auxiliary_filters;
2202      struct bfd_link_info *info;
2203      asection **sinterpptr;
2204      struct bfd_elf_version_tree *verdefs;
2205 {
2206   bfd_size_type soname_indx;
2207   bfd *dynobj;
2208   struct elf_backend_data *bed;
2209   bfd_size_type old_dynsymcount;
2210   struct elf_assign_sym_version_info asvinfo;
2211
2212   *sinterpptr = NULL;
2213
2214   soname_indx = -1;
2215
2216   if (info->hash->creator->flavour != bfd_target_elf_flavour)
2217     return true;
2218
2219   /* The backend may have to create some sections regardless of whether
2220      we're dynamic or not.  */
2221   bed = get_elf_backend_data (output_bfd);
2222   if (bed->elf_backend_always_size_sections
2223       && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
2224     return false;
2225
2226   dynobj = elf_hash_table (info)->dynobj;
2227
2228   /* If there were no dynamic objects in the link, there is nothing to
2229      do here.  */
2230   if (dynobj == NULL)
2231     return true;
2232
2233   /* If we are supposed to export all symbols into the dynamic symbol
2234      table (this is not the normal case), then do so.  */
2235   if (export_dynamic)
2236     {
2237       struct elf_info_failed eif;
2238
2239       eif.failed = false;
2240       eif.info = info;
2241       elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
2242                               (PTR) &eif);
2243       if (eif.failed)
2244         return false;
2245     }
2246
2247   if (elf_hash_table (info)->dynamic_sections_created)
2248     {
2249       struct elf_info_failed eif;
2250       struct elf_link_hash_entry *h;
2251       bfd_size_type strsize;
2252
2253       *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
2254       BFD_ASSERT (*sinterpptr != NULL || info->shared);
2255
2256       if (soname != NULL)
2257         {
2258           soname_indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2259                                             soname, true, true);
2260           if (soname_indx == (bfd_size_type) -1
2261               || ! elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
2262             return false;
2263         }
2264
2265       if (info->symbolic)
2266         {
2267           if (! elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
2268             return false;
2269         }
2270
2271       if (rpath != NULL)
2272         {
2273           bfd_size_type indx;
2274
2275           indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
2276                                      true, true);
2277           if (indx == (bfd_size_type) -1
2278               || ! elf_add_dynamic_entry (info, DT_RPATH, indx))
2279             return false;
2280         }
2281
2282       if (filter_shlib != NULL)
2283         {
2284           bfd_size_type indx;
2285
2286           indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2287                                      filter_shlib, true, true);
2288           if (indx == (bfd_size_type) -1
2289               || ! elf_add_dynamic_entry (info, DT_FILTER, indx))
2290             return false;
2291         }
2292
2293       if (auxiliary_filters != NULL)
2294         {
2295           const char * const *p;
2296
2297           for (p = auxiliary_filters; *p != NULL; p++)
2298             {
2299               bfd_size_type indx;
2300
2301               indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2302                                          *p, true, true);
2303               if (indx == (bfd_size_type) -1
2304                   || ! elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
2305                 return false;
2306             }
2307         }
2308
2309       /* Attach all the symbols to their version information.  */
2310       asvinfo.output_bfd = output_bfd;
2311       asvinfo.info = info;
2312       asvinfo.verdefs = verdefs;
2313       asvinfo.export_dynamic = export_dynamic;
2314       asvinfo.removed_dynamic = false;
2315       asvinfo.failed = false;
2316
2317       elf_link_hash_traverse (elf_hash_table (info),
2318                               elf_link_assign_sym_version,
2319                               (PTR) &asvinfo);
2320       if (asvinfo.failed)
2321         return false;
2322
2323       /* Find all symbols which were defined in a dynamic object and make
2324          the backend pick a reasonable value for them.  */
2325       eif.failed = false;
2326       eif.info = info;
2327       elf_link_hash_traverse (elf_hash_table (info),
2328                               elf_adjust_dynamic_symbol,
2329                               (PTR) &eif);
2330       if (eif.failed)
2331         return false;
2332
2333       /* Add some entries to the .dynamic section.  We fill in some of the
2334          values later, in elf_bfd_final_link, but we must add the entries
2335          now so that we know the final size of the .dynamic section.  */
2336       h =  elf_link_hash_lookup (elf_hash_table (info), "_init", false,
2337                                 false, false);
2338       if (h != NULL
2339           && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
2340                                         | ELF_LINK_HASH_DEF_REGULAR)) != 0)
2341         {
2342           if (! elf_add_dynamic_entry (info, DT_INIT, 0))
2343             return false;
2344         }
2345       h =  elf_link_hash_lookup (elf_hash_table (info), "_fini", false,
2346                                  false, false);
2347       if (h != NULL
2348           && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
2349                                         | ELF_LINK_HASH_DEF_REGULAR)) != 0)
2350         {
2351           if (! elf_add_dynamic_entry (info, DT_FINI, 0))
2352             return false;
2353         }
2354       strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
2355       if (! elf_add_dynamic_entry (info, DT_HASH, 0)
2356           || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
2357           || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
2358           || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
2359           || ! elf_add_dynamic_entry (info, DT_SYMENT,
2360                                       sizeof (Elf_External_Sym)))
2361         return false;
2362     }
2363
2364   /* The backend must work out the sizes of all the other dynamic
2365      sections.  */
2366   old_dynsymcount = elf_hash_table (info)->dynsymcount;
2367   if (! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
2368     return false;
2369
2370   if (elf_hash_table (info)->dynamic_sections_created)
2371     {
2372       size_t dynsymcount;
2373       asection *s;
2374       size_t i;
2375       size_t bucketcount = 0;
2376       Elf_Internal_Sym isym;
2377
2378       /* Set up the version definition section.  */
2379       s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
2380       BFD_ASSERT (s != NULL);
2381
2382       /* We may have created additional version definitions if we are
2383          just linking a regular application.  */
2384       verdefs = asvinfo.verdefs;
2385
2386       if (verdefs == NULL)
2387         {
2388           asection **spp;
2389
2390           /* Don't include this section in the output file.  */
2391           for (spp = &output_bfd->sections;
2392                *spp != s->output_section;
2393                spp = &(*spp)->next)
2394             ;
2395           *spp = s->output_section->next;
2396           --output_bfd->section_count;
2397         }
2398       else
2399         {
2400           unsigned int cdefs;
2401           bfd_size_type size;
2402           struct bfd_elf_version_tree *t;
2403           bfd_byte *p;
2404           Elf_Internal_Verdef def;
2405           Elf_Internal_Verdaux defaux;
2406
2407           if (asvinfo.removed_dynamic)
2408             {
2409               /* Some dynamic symbols were changed to be local
2410                  symbols.  In this case, we renumber all of the
2411                  dynamic symbols, so that we don't have a hole.  If
2412                  the backend changed dynsymcount, then assume that the
2413                  new symbols are at the start.  This is the case on
2414                  the MIPS.  FIXME: The names of the removed symbols
2415                  will still be in the dynamic string table, wasting
2416                  space.  */
2417               elf_hash_table (info)->dynsymcount =
2418                 1 + (elf_hash_table (info)->dynsymcount - old_dynsymcount);
2419               elf_link_hash_traverse (elf_hash_table (info),
2420                                       elf_link_renumber_dynsyms,
2421                                       (PTR) info);
2422             }
2423
2424           cdefs = 0;
2425           size = 0;
2426
2427           /* Make space for the base version.  */
2428           size += sizeof (Elf_External_Verdef);
2429           size += sizeof (Elf_External_Verdaux);
2430           ++cdefs;
2431
2432           for (t = verdefs; t != NULL; t = t->next)
2433             {
2434               struct bfd_elf_version_deps *n;
2435
2436               size += sizeof (Elf_External_Verdef);
2437               size += sizeof (Elf_External_Verdaux);
2438               ++cdefs;
2439
2440               for (n = t->deps; n != NULL; n = n->next)
2441                 size += sizeof (Elf_External_Verdaux);
2442             }
2443
2444           s->_raw_size = size;
2445           s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
2446           if (s->contents == NULL && s->_raw_size != 0)
2447             return false;
2448
2449           /* Fill in the version definition section.  */
2450
2451           p = s->contents;
2452
2453           def.vd_version = VER_DEF_CURRENT;
2454           def.vd_flags = VER_FLG_BASE;
2455           def.vd_ndx = 1;
2456           def.vd_cnt = 1;
2457           def.vd_aux = sizeof (Elf_External_Verdef);
2458           def.vd_next = (sizeof (Elf_External_Verdef)
2459                          + sizeof (Elf_External_Verdaux));
2460
2461           if (soname_indx != -1)
2462             {
2463               def.vd_hash = bfd_elf_hash ((const unsigned char *) soname);
2464               defaux.vda_name = soname_indx;
2465             }
2466           else
2467             {
2468               const char *name;
2469               bfd_size_type indx;
2470
2471               name = output_bfd->filename;
2472               def.vd_hash = bfd_elf_hash ((const unsigned char *) name);
2473               indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2474                                             name, true, false);
2475               if (indx == (bfd_size_type) -1)
2476                 return false;
2477               defaux.vda_name = indx;
2478             }
2479           defaux.vda_next = 0;
2480
2481           _bfd_elf_swap_verdef_out (output_bfd, &def,
2482                                     (Elf_External_Verdef *)p);
2483           p += sizeof (Elf_External_Verdef);
2484           _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
2485                                      (Elf_External_Verdaux *) p);
2486           p += sizeof (Elf_External_Verdaux);
2487
2488           for (t = verdefs; t != NULL; t = t->next)
2489             {
2490               unsigned int cdeps;
2491               struct bfd_elf_version_deps *n;
2492               struct elf_link_hash_entry *h;
2493
2494               cdeps = 0;
2495               for (n = t->deps; n != NULL; n = n->next)
2496                 ++cdeps;
2497
2498               /* Add a symbol representing this version.  */
2499               h = NULL;
2500               if (! (_bfd_generic_link_add_one_symbol
2501                      (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
2502                       (bfd_vma) 0, (const char *) NULL, false,
2503                       get_elf_backend_data (dynobj)->collect,
2504                       (struct bfd_link_hash_entry **) &h)))
2505                 return false;
2506               h->elf_link_hash_flags &= ~ ELF_LINK_NON_ELF;
2507               h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2508               h->type = STT_OBJECT;
2509               h->verinfo.vertree = t;
2510
2511               if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2512                 return false;
2513
2514               def.vd_version = VER_DEF_CURRENT;
2515               def.vd_flags = 0;
2516               if (t->globals == NULL && t->locals == NULL && ! t->used)
2517                 def.vd_flags |= VER_FLG_WEAK;
2518               def.vd_ndx = t->vernum + 1;
2519               def.vd_cnt = cdeps + 1;
2520               def.vd_hash = bfd_elf_hash ((const unsigned char *) t->name);
2521               def.vd_aux = sizeof (Elf_External_Verdef);
2522               if (t->next != NULL)
2523                 def.vd_next = (sizeof (Elf_External_Verdef)
2524                                + (cdeps + 1) * sizeof (Elf_External_Verdaux));
2525               else
2526                 def.vd_next = 0;
2527
2528               _bfd_elf_swap_verdef_out (output_bfd, &def,
2529                                         (Elf_External_Verdef *) p);
2530               p += sizeof (Elf_External_Verdef);
2531
2532               defaux.vda_name = h->dynstr_index;
2533               if (t->deps == NULL)
2534                 defaux.vda_next = 0;
2535               else
2536                 defaux.vda_next = sizeof (Elf_External_Verdaux);
2537               t->name_indx = defaux.vda_name;
2538
2539               _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
2540                                          (Elf_External_Verdaux *) p);
2541               p += sizeof (Elf_External_Verdaux);
2542
2543               for (n = t->deps; n != NULL; n = n->next)
2544                 {
2545                   defaux.vda_name = n->version_needed->name_indx;
2546                   if (n->next == NULL)
2547                     defaux.vda_next = 0;
2548                   else
2549                     defaux.vda_next = sizeof (Elf_External_Verdaux);
2550
2551                   _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
2552                                              (Elf_External_Verdaux *) p);
2553                   p += sizeof (Elf_External_Verdaux);
2554                 }
2555             }
2556
2557           if (! elf_add_dynamic_entry (info, DT_VERDEF, 0)
2558               || ! elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
2559             return false;
2560
2561           elf_tdata (output_bfd)->cverdefs = cdefs;
2562         }
2563
2564       /* Work out the size of the version reference section.  */
2565
2566       s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
2567       BFD_ASSERT (s != NULL);
2568       {
2569         struct elf_find_verdep_info sinfo;
2570
2571         sinfo.output_bfd = output_bfd;
2572         sinfo.info = info;
2573         sinfo.vers = elf_tdata (output_bfd)->cverdefs;
2574         if (sinfo.vers == 0)
2575           sinfo.vers = 1;
2576         sinfo.failed = false;
2577
2578         elf_link_hash_traverse (elf_hash_table (info),
2579                                 elf_link_find_version_dependencies,
2580                                 (PTR) &sinfo);
2581
2582         if (elf_tdata (output_bfd)->verref == NULL)
2583           {
2584             asection **spp;
2585
2586             /* We don't have any version definitions, so we can just
2587                remove the section.  */
2588
2589             for (spp = &output_bfd->sections;
2590                  *spp != s->output_section;
2591                  spp = &(*spp)->next)
2592               ;
2593             *spp = s->output_section->next;
2594             --output_bfd->section_count;
2595           }
2596         else
2597           {
2598             Elf_Internal_Verneed *t;
2599             unsigned int size;
2600             unsigned int crefs;
2601             bfd_byte *p;
2602
2603             /* Build the version definition section.  */
2604             size = 0;
2605             crefs = 0;
2606             for (t = elf_tdata (output_bfd)->verref;
2607                  t != NULL;
2608                  t = t->vn_nextref)
2609               {
2610                 Elf_Internal_Vernaux *a;
2611
2612                 size += sizeof (Elf_External_Verneed);
2613                 ++crefs;
2614                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
2615                   size += sizeof (Elf_External_Vernaux);
2616               }
2617
2618             s->_raw_size = size;
2619             s->contents = (bfd_byte *) bfd_alloc (output_bfd, size);
2620             if (s->contents == NULL)
2621               return false;
2622
2623             p = s->contents;
2624             for (t = elf_tdata (output_bfd)->verref;
2625                  t != NULL;
2626                  t = t->vn_nextref)
2627               {
2628                 unsigned int caux;
2629                 Elf_Internal_Vernaux *a;
2630                 bfd_size_type indx;
2631
2632                 caux = 0;
2633                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
2634                   ++caux;
2635
2636                 t->vn_version = VER_NEED_CURRENT;
2637                 t->vn_cnt = caux;
2638                 if (elf_dt_name (t->vn_bfd) != NULL)
2639                   indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2640                                              elf_dt_name (t->vn_bfd),
2641                                              true, false);
2642                 else
2643                   indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2644                                              t->vn_bfd->filename, true, false);
2645                 if (indx == (bfd_size_type) -1)
2646                   return false;
2647                 t->vn_file = indx;
2648                 t->vn_aux = sizeof (Elf_External_Verneed);
2649                 if (t->vn_nextref == NULL)
2650                   t->vn_next = 0;
2651                 else
2652                   t->vn_next = (sizeof (Elf_External_Verneed)
2653                                 + caux * sizeof (Elf_External_Vernaux));
2654
2655                 _bfd_elf_swap_verneed_out (output_bfd, t,
2656                                            (Elf_External_Verneed *) p);
2657                 p += sizeof (Elf_External_Verneed);
2658
2659                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
2660                   {
2661                     a->vna_hash = bfd_elf_hash ((const unsigned char *)
2662                                                 a->vna_nodename);
2663                     indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2664                                                a->vna_nodename, true, false);
2665                     if (indx == (bfd_size_type) -1)
2666                       return false;
2667                     a->vna_name = indx;
2668                     if (a->vna_nextptr == NULL)
2669                       a->vna_next = 0;
2670                     else
2671                       a->vna_next = sizeof (Elf_External_Vernaux);
2672
2673                     _bfd_elf_swap_vernaux_out (output_bfd, a,
2674                                                (Elf_External_Vernaux *) p);
2675                     p += sizeof (Elf_External_Vernaux);
2676                   }
2677               }
2678
2679             if (! elf_add_dynamic_entry (info, DT_VERNEED, 0)
2680                 || ! elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
2681               return false;
2682
2683             elf_tdata (output_bfd)->cverrefs = crefs;
2684           }
2685       }
2686
2687       dynsymcount = elf_hash_table (info)->dynsymcount;
2688
2689       /* Work out the size of the symbol version section.  */
2690       s = bfd_get_section_by_name (dynobj, ".gnu.version");
2691       BFD_ASSERT (s != NULL);
2692       if (dynsymcount == 0
2693           || (verdefs == NULL && elf_tdata (output_bfd)->verref == NULL))
2694         {
2695           asection **spp;
2696
2697           /* We don't need any symbol versions; just discard the
2698              section.  */
2699           for (spp = &output_bfd->sections;
2700                *spp != s->output_section;
2701                spp = &(*spp)->next)
2702             ;
2703           *spp = s->output_section->next;
2704           --output_bfd->section_count;
2705         }
2706       else
2707         {
2708           s->_raw_size = dynsymcount * sizeof (Elf_External_Versym);
2709           s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
2710           if (s->contents == NULL)
2711             return false;
2712
2713           if (! elf_add_dynamic_entry (info, DT_VERSYM, 0))
2714             return false;
2715         }
2716
2717       /* Set the size of the .dynsym and .hash sections.  We counted
2718          the number of dynamic symbols in elf_link_add_object_symbols.
2719          We will build the contents of .dynsym and .hash when we build
2720          the final symbol table, because until then we do not know the
2721          correct value to give the symbols.  We built the .dynstr
2722          section as we went along in elf_link_add_object_symbols.  */
2723       s = bfd_get_section_by_name (dynobj, ".dynsym");
2724       BFD_ASSERT (s != NULL);
2725       s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
2726       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
2727       if (s->contents == NULL && s->_raw_size != 0)
2728         return false;
2729
2730       /* The first entry in .dynsym is a dummy symbol.  */
2731       isym.st_value = 0;
2732       isym.st_size = 0;
2733       isym.st_name = 0;
2734       isym.st_info = 0;
2735       isym.st_other = 0;
2736       isym.st_shndx = 0;
2737       elf_swap_symbol_out (output_bfd, &isym,
2738                            (PTR) (Elf_External_Sym *) s->contents);
2739
2740       for (i = 0; elf_buckets[i] != 0; i++)
2741         {
2742           bucketcount = elf_buckets[i];
2743           if (dynsymcount < elf_buckets[i + 1])
2744             break;
2745         }
2746
2747       s = bfd_get_section_by_name (dynobj, ".hash");
2748       BFD_ASSERT (s != NULL);
2749       s->_raw_size = (2 + bucketcount + dynsymcount) * (ARCH_SIZE / 8);
2750       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
2751       if (s->contents == NULL)
2752         return false;
2753       memset (s->contents, 0, (size_t) s->_raw_size);
2754
2755       put_word (output_bfd, bucketcount, s->contents);
2756       put_word (output_bfd, dynsymcount, s->contents + (ARCH_SIZE / 8));
2757
2758       elf_hash_table (info)->bucketcount = bucketcount;
2759
2760       s = bfd_get_section_by_name (dynobj, ".dynstr");
2761       BFD_ASSERT (s != NULL);
2762       s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
2763
2764       if (! elf_add_dynamic_entry (info, DT_NULL, 0))
2765         return false;
2766     }
2767
2768   return true;
2769 }
2770 \f
2771 /* Fix up the flags for a symbol.  This handles various cases which
2772    can only be fixed after all the input files are seen.  This is
2773    currently called by both adjust_dynamic_symbol and
2774    assign_sym_version, which is unnecessary but perhaps more robust in
2775    the face of future changes.  */
2776
2777 static boolean
2778 elf_fix_symbol_flags (h, eif)
2779      struct elf_link_hash_entry *h;
2780      struct elf_info_failed *eif;
2781 {
2782   /* If this symbol was mentioned in a non-ELF file, try to set
2783      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
2784      permit a non-ELF file to correctly refer to a symbol defined in
2785      an ELF dynamic object.  */
2786   if ((h->elf_link_hash_flags & ELF_LINK_NON_ELF) != 0)
2787     {
2788       if (h->root.type != bfd_link_hash_defined
2789           && h->root.type != bfd_link_hash_defweak)
2790         h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2791       else
2792         {
2793           if (h->root.u.def.section->owner != NULL
2794               && (bfd_get_flavour (h->root.u.def.section->owner)
2795                   == bfd_target_elf_flavour))
2796             h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2797           else
2798             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2799         }
2800
2801       if (h->dynindx == -1
2802           && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2803               || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0))
2804         {
2805           if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
2806             {
2807               eif->failed = true;
2808               return false;
2809             }
2810         }
2811     }
2812
2813   /* If this is a final link, and the symbol was defined as a common
2814      symbol in a regular object file, and there was no definition in
2815      any dynamic object, then the linker will have allocated space for
2816      the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
2817      flag will not have been set.  */
2818   if (h->root.type == bfd_link_hash_defined
2819       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2820       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) != 0
2821       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2822       && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
2823     h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2824
2825   /* If -Bsymbolic was used (which means to bind references to global
2826      symbols to the definition within the shared object), and this
2827      symbol was defined in a regular object, then it actually doesn't
2828      need a PLT entry.  */
2829   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
2830       && eif->info->shared
2831       && eif->info->symbolic
2832       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
2833     h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
2834
2835   return true;
2836 }
2837
2838 /* Make the backend pick a good value for a dynamic symbol.  This is
2839    called via elf_link_hash_traverse, and also calls itself
2840    recursively.  */
2841
2842 static boolean
2843 elf_adjust_dynamic_symbol (h, data)
2844      struct elf_link_hash_entry *h;
2845      PTR data;
2846 {
2847   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2848   bfd *dynobj;
2849   struct elf_backend_data *bed;
2850
2851   /* Ignore indirect symbols.  These are added by the versioning code.  */
2852   if (h->root.type == bfd_link_hash_indirect)
2853     return true;
2854
2855   /* Fix the symbol flags.  */
2856   if (! elf_fix_symbol_flags (h, eif))
2857     return false;
2858
2859   /* If this symbol does not require a PLT entry, and it is not
2860      defined by a dynamic object, or is not referenced by a regular
2861      object, ignore it.  We do have to handle a weak defined symbol,
2862      even if no regular object refers to it, if we decided to add it
2863      to the dynamic symbol table.  FIXME: Do we normally need to worry
2864      about symbols which are defined by one dynamic object and
2865      referenced by another one?  */
2866   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
2867       && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2868           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2869           || ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
2870               && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
2871     return true;
2872
2873   /* If we've already adjusted this symbol, don't do it again.  This
2874      can happen via a recursive call.  */
2875   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
2876     return true;
2877
2878   /* Don't look at this symbol again.  Note that we must set this
2879      after checking the above conditions, because we may look at a
2880      symbol once, decide not to do anything, and then get called
2881      recursively later after REF_REGULAR is set below.  */
2882   h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
2883
2884   /* If this is a weak definition, and we know a real definition, and
2885      the real symbol is not itself defined by a regular object file,
2886      then get a good value for the real definition.  We handle the
2887      real symbol first, for the convenience of the backend routine.
2888
2889      Note that there is a confusing case here.  If the real definition
2890      is defined by a regular object file, we don't get the real symbol
2891      from the dynamic object, but we do get the weak symbol.  If the
2892      processor backend uses a COPY reloc, then if some routine in the
2893      dynamic object changes the real symbol, we will not see that
2894      change in the corresponding weak symbol.  This is the way other
2895      ELF linkers work as well, and seems to be a result of the shared
2896      library model.
2897
2898      I will clarify this issue.  Most SVR4 shared libraries define the
2899      variable _timezone and define timezone as a weak synonym.  The
2900      tzset call changes _timezone.  If you write
2901        extern int timezone;
2902        int _timezone = 5;
2903        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2904      you might expect that, since timezone is a synonym for _timezone,
2905      the same number will print both times.  However, if the processor
2906      backend uses a COPY reloc, then actually timezone will be copied
2907      into your process image, and, since you define _timezone
2908      yourself, _timezone will not.  Thus timezone and _timezone will
2909      wind up at different memory locations.  The tzset call will set
2910      _timezone, leaving timezone unchanged.  */
2911
2912   if (h->weakdef != NULL)
2913     {
2914       struct elf_link_hash_entry *weakdef;
2915
2916       BFD_ASSERT (h->root.type == bfd_link_hash_defined
2917                   || h->root.type == bfd_link_hash_defweak);
2918       weakdef = h->weakdef;
2919       BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2920                   || weakdef->root.type == bfd_link_hash_defweak);
2921       BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
2922       if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
2923         {
2924           /* This symbol is defined by a regular object file, so we
2925              will not do anything special.  Clear weakdef for the
2926              convenience of the processor backend.  */
2927           h->weakdef = NULL;
2928         }
2929       else
2930         {
2931           /* There is an implicit reference by a regular object file
2932              via the weak symbol.  */
2933           weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2934           if (! elf_adjust_dynamic_symbol (weakdef, (PTR) eif))
2935             return false;
2936         }
2937     }
2938
2939   dynobj = elf_hash_table (eif->info)->dynobj;
2940   bed = get_elf_backend_data (dynobj);
2941   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2942     {
2943       eif->failed = true;
2944       return false;
2945     }
2946
2947   return true;
2948 }
2949 \f
2950 /* This routine is used to export all defined symbols into the dynamic
2951    symbol table.  It is called via elf_link_hash_traverse.  */
2952
2953 static boolean
2954 elf_export_symbol (h, data)
2955      struct elf_link_hash_entry *h;
2956      PTR data;
2957 {
2958   struct elf_info_failed *eif = (struct elf_info_failed *) data;
2959
2960   /* Ignore indirect symbols.  These are added by the versioning code.  */
2961   if (h->root.type == bfd_link_hash_indirect)
2962     return true;
2963
2964   if (h->dynindx == -1
2965       && (h->elf_link_hash_flags
2966           & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
2967     {
2968       if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
2969         {
2970           eif->failed = true;
2971           return false;
2972         }
2973     }
2974
2975   return true;
2976 }
2977 \f
2978 /* Look through the symbols which are defined in other shared
2979    libraries and referenced here.  Update the list of version
2980    dependencies.  This will be put into the .gnu.version_r section.
2981    This function is called via elf_link_hash_traverse.  */
2982
2983 static boolean
2984 elf_link_find_version_dependencies (h, data)
2985      struct elf_link_hash_entry *h;
2986      PTR data;
2987 {
2988   struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
2989   Elf_Internal_Verneed *t;
2990   Elf_Internal_Vernaux *a;
2991
2992   /* We only care about symbols defined in shared objects with version
2993      information.  */
2994   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2995       || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2996       || h->dynindx == -1
2997       || h->verinfo.verdef == NULL)
2998     return true;
2999
3000   /* See if we already know about this version.  */
3001   for (t = elf_tdata (rinfo->output_bfd)->verref; t != NULL; t = t->vn_nextref)
3002     {
3003       if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
3004         continue;
3005
3006       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3007         if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
3008           return true;
3009
3010       break;
3011     }
3012
3013   /* This is a new version.  Add it to tree we are building.  */
3014
3015   if (t == NULL)
3016     {
3017       t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->output_bfd, sizeof *t);
3018       if (t == NULL)
3019         {
3020           rinfo->failed = true;
3021           return false;
3022         }
3023
3024       t->vn_bfd = h->verinfo.verdef->vd_bfd;
3025       t->vn_nextref = elf_tdata (rinfo->output_bfd)->verref;
3026       elf_tdata (rinfo->output_bfd)->verref = t;
3027     }
3028
3029   a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->output_bfd, sizeof *a);
3030
3031   /* Note that we are copying a string pointer here, and testing it
3032      above.  If bfd_elf_string_from_elf_section is ever changed to
3033      discard the string data when low in memory, this will have to be
3034      fixed.  */
3035   a->vna_nodename = h->verinfo.verdef->vd_nodename;
3036
3037   a->vna_flags = h->verinfo.verdef->vd_flags;
3038   a->vna_nextptr = t->vn_auxptr;
3039
3040   h->verinfo.verdef->vd_exp_refno = rinfo->vers;
3041   ++rinfo->vers;
3042
3043   a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
3044
3045   t->vn_auxptr = a;
3046
3047   return true;
3048 }
3049
3050 /* Figure out appropriate versions for all the symbols.  We may not
3051    have the version number script until we have read all of the input
3052    files, so until that point we don't know which symbols should be
3053    local.  This function is called via elf_link_hash_traverse.  */
3054
3055 static boolean
3056 elf_link_assign_sym_version (h, data)
3057      struct elf_link_hash_entry *h;
3058      PTR data;
3059 {
3060   struct elf_assign_sym_version_info *sinfo =
3061     (struct elf_assign_sym_version_info *) data;
3062   struct bfd_link_info *info = sinfo->info;
3063   struct elf_info_failed eif;
3064   char *p;
3065
3066   /* Fix the symbol flags.  */
3067   eif.failed = false;
3068   eif.info = info;
3069   if (! elf_fix_symbol_flags (h, &eif))
3070     {
3071       if (eif.failed)
3072         sinfo->failed = true;
3073       return false;
3074     }
3075
3076   /* We only need version numbers for symbols defined in regular
3077      objects.  */
3078   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3079     return true;
3080
3081   p = strchr (h->root.root.string, ELF_VER_CHR);
3082   if (p != NULL && h->verinfo.vertree == NULL)
3083     {
3084       struct bfd_elf_version_tree *t;
3085       boolean hidden;
3086
3087       hidden = true;
3088
3089       /* There are two consecutive ELF_VER_CHR characters if this is
3090          not a hidden symbol.  */
3091       ++p;
3092       if (*p == ELF_VER_CHR)
3093         {
3094           hidden = false;
3095           ++p;
3096         }
3097
3098       /* If there is no version string, we can just return out.  */
3099       if (*p == '\0')
3100         {
3101           if (hidden)
3102             h->elf_link_hash_flags |= ELF_LINK_HIDDEN;
3103           return true;
3104         }
3105
3106       /* Look for the version.  If we find it, it is no longer weak.  */
3107       for (t = sinfo->verdefs; t != NULL; t = t->next)
3108         {
3109           if (strcmp (t->name, p) == 0)
3110             {
3111               h->verinfo.vertree = t;
3112               t->used = true;
3113
3114               /* See if there is anything to force this symbol to
3115                  local scope.  */
3116               if (t->locals != NULL)
3117                 {
3118                   int len;
3119                   char *alc;
3120                   struct bfd_elf_version_expr *d;
3121
3122                   len = p - h->root.root.string;
3123                   alc = bfd_alloc (sinfo->output_bfd, len);
3124                   if (alc == NULL)
3125                     return false;
3126                   strncpy (alc, h->root.root.string, len - 1);
3127                   alc[len - 1] = '\0';
3128                   if (alc[len - 2] == ELF_VER_CHR)
3129                     alc[len - 2] = '\0';
3130
3131                   for (d = t->locals; d != NULL; d = d->next)
3132                     {
3133                       if ((d->match[0] == '*' && d->match[1] == '\0')
3134                           || fnmatch (d->match, alc, 0) == 0)
3135                         {
3136                           if (h->dynindx != -1
3137                               && info->shared
3138                               && ! sinfo->export_dynamic)
3139                             {
3140                               sinfo->removed_dynamic = true;
3141                               h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
3142                               h->elf_link_hash_flags &=~
3143                                 ELF_LINK_HASH_NEEDS_PLT;
3144                               h->dynindx = -1;
3145                               /* FIXME: The name of the symbol has
3146                                  already been recorded in the dynamic
3147                                  string table section.  */
3148                             }
3149
3150                           break;
3151                         }
3152                     }
3153
3154                   bfd_release (sinfo->output_bfd, alc);
3155                 }
3156
3157               break;
3158             }
3159         }
3160
3161       /* If we are building an application, we need to create a
3162          version node for this version.  */
3163       if (t == NULL && ! info->shared)
3164         {
3165           struct bfd_elf_version_tree **pp;
3166           int version_index;
3167
3168           /* If we aren't going to export this symbol, we don't need
3169              to worry about it. */
3170           if (h->dynindx == -1)
3171             return true;
3172
3173           t = ((struct bfd_elf_version_tree *)
3174                bfd_alloc (sinfo->output_bfd, sizeof *t));
3175           if (t == NULL)
3176             {
3177               sinfo->failed = true;
3178               return false;
3179             }
3180
3181           t->next = NULL;
3182           t->name = p;
3183           t->globals = NULL;
3184           t->locals = NULL;
3185           t->deps = NULL;
3186           t->name_indx = (unsigned int) -1;
3187           t->used = true;
3188
3189           version_index = 1;
3190           for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next)
3191             ++version_index;
3192           t->vernum = version_index;
3193
3194           *pp = t;
3195
3196           h->verinfo.vertree = t;
3197         }
3198       else if (t == NULL)
3199         {
3200           /* We could not find the version for a symbol when
3201              generating a shared archive.  Return an error.  */
3202           (*_bfd_error_handler)
3203             ("%s: undefined version name %s",
3204              bfd_get_filename (sinfo->output_bfd), h->root.root.string);
3205           bfd_set_error (bfd_error_bad_value);
3206           sinfo->failed = true;
3207           return false;
3208         }
3209
3210       if (hidden)
3211         h->elf_link_hash_flags |= ELF_LINK_HIDDEN;
3212     }
3213
3214   /* If we don't have a version for this symbol, see if we can find
3215      something.  */
3216   if (h->verinfo.vertree == NULL && sinfo->verdefs != NULL)
3217     {
3218       struct bfd_elf_version_tree *t;
3219       struct bfd_elf_version_tree *deflt;
3220       struct bfd_elf_version_expr *d;
3221
3222       /* See if can find what version this symbol is in.  If the
3223          symbol is supposed to be local, then don't actually register
3224          it.  */
3225       deflt = NULL;
3226       for (t = sinfo->verdefs; t != NULL; t = t->next)
3227         {
3228           if (t->globals != NULL)
3229             {
3230               for (d = t->globals; d != NULL; d = d->next)
3231                 {
3232                   if (fnmatch (d->match, h->root.root.string, 0) == 0)
3233                     {
3234                       h->verinfo.vertree = t;
3235                       break;
3236                     }
3237                 }
3238
3239               if (d != NULL)
3240                 break;
3241             }
3242
3243           if (t->locals != NULL)
3244             {
3245               for (d = t->locals; d != NULL; d = d->next)
3246                 {
3247                   if (d->match[0] == '*' && d->match[1] == '\0')
3248                     deflt = t;
3249                   else if (fnmatch (d->match, h->root.root.string, 0) == 0)
3250                     {
3251                       h->verinfo.vertree = t;
3252                       if (h->dynindx != -1
3253                           && info->shared
3254                           && ! sinfo->export_dynamic)
3255                         {
3256                           sinfo->removed_dynamic = true;
3257                           h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
3258                           h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
3259                           h->dynindx = -1;
3260                           /* FIXME: The name of the symbol has already
3261                              been recorded in the dynamic string table
3262                              section.  */
3263                         }
3264                       break;
3265                     }
3266                 }
3267
3268               if (d != NULL)
3269                 break;
3270             }
3271         }
3272
3273       if (deflt != NULL && h->verinfo.vertree == NULL)
3274         {
3275           h->verinfo.vertree = deflt;
3276           if (h->dynindx != -1
3277               && info->shared
3278               && ! sinfo->export_dynamic)
3279             {
3280               sinfo->removed_dynamic = true;
3281               h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
3282               h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
3283               h->dynindx = -1;
3284               /* FIXME: The name of the symbol has already been
3285                  recorded in the dynamic string table section.  */
3286             }
3287         }
3288     }
3289
3290   return true;
3291 }
3292
3293 /* This function is used to renumber the dynamic symbols, if some of
3294    them are removed because they are marked as local.  This is called
3295    via elf_link_hash_traverse.  */
3296
3297 static boolean
3298 elf_link_renumber_dynsyms (h, data)
3299      struct elf_link_hash_entry *h;
3300      PTR data;
3301 {
3302   struct bfd_link_info *info = (struct bfd_link_info *) data;
3303
3304   if (h->dynindx != -1)
3305     {
3306       h->dynindx = elf_hash_table (info)->dynsymcount;
3307       ++elf_hash_table (info)->dynsymcount;
3308     }
3309
3310   return true;
3311 }
3312 \f
3313 /* Final phase of ELF linker.  */
3314
3315 /* A structure we use to avoid passing large numbers of arguments.  */
3316
3317 struct elf_final_link_info
3318 {
3319   /* General link information.  */
3320   struct bfd_link_info *info;
3321   /* Output BFD.  */
3322   bfd *output_bfd;
3323   /* Symbol string table.  */
3324   struct bfd_strtab_hash *symstrtab;
3325   /* .dynsym section.  */
3326   asection *dynsym_sec;
3327   /* .hash section.  */
3328   asection *hash_sec;
3329   /* symbol version section (.gnu.version).  */
3330   asection *symver_sec;
3331   /* Buffer large enough to hold contents of any section.  */
3332   bfd_byte *contents;
3333   /* Buffer large enough to hold external relocs of any section.  */
3334   PTR external_relocs;
3335   /* Buffer large enough to hold internal relocs of any section.  */
3336   Elf_Internal_Rela *internal_relocs;
3337   /* Buffer large enough to hold external local symbols of any input
3338      BFD.  */
3339   Elf_External_Sym *external_syms;
3340   /* Buffer large enough to hold internal local symbols of any input
3341      BFD.  */
3342   Elf_Internal_Sym *internal_syms;
3343   /* Array large enough to hold a symbol index for each local symbol
3344      of any input BFD.  */
3345   long *indices;
3346   /* Array large enough to hold a section pointer for each local
3347      symbol of any input BFD.  */
3348   asection **sections;
3349   /* Buffer to hold swapped out symbols.  */
3350   Elf_External_Sym *symbuf;
3351   /* Number of swapped out symbols in buffer.  */
3352   size_t symbuf_count;
3353   /* Number of symbols which fit in symbuf.  */
3354   size_t symbuf_size;
3355 };
3356
3357 static boolean elf_link_output_sym
3358   PARAMS ((struct elf_final_link_info *, const char *,
3359            Elf_Internal_Sym *, asection *));
3360 static boolean elf_link_flush_output_syms
3361   PARAMS ((struct elf_final_link_info *));
3362 static boolean elf_link_output_extsym
3363   PARAMS ((struct elf_link_hash_entry *, PTR));
3364 static boolean elf_link_input_bfd
3365   PARAMS ((struct elf_final_link_info *, bfd *));
3366 static boolean elf_reloc_link_order
3367   PARAMS ((bfd *, struct bfd_link_info *, asection *,
3368            struct bfd_link_order *));
3369
3370 /* This struct is used to pass information to elf_link_output_extsym.  */
3371
3372 struct elf_outext_info
3373 {
3374   boolean failed;
3375   boolean localsyms;
3376   struct elf_final_link_info *finfo;
3377 };
3378
3379 /* Do the final step of an ELF link.  */
3380
3381 boolean
3382 elf_bfd_final_link (abfd, info)
3383      bfd *abfd;
3384      struct bfd_link_info *info;
3385 {
3386   boolean dynamic;
3387   bfd *dynobj;
3388   struct elf_final_link_info finfo;
3389   register asection *o;
3390   register struct bfd_link_order *p;
3391   register bfd *sub;
3392   size_t max_contents_size;
3393   size_t max_external_reloc_size;
3394   size_t max_internal_reloc_count;
3395   size_t max_sym_count;
3396   file_ptr off;
3397   Elf_Internal_Sym elfsym;
3398   unsigned int i;
3399   Elf_Internal_Shdr *symtab_hdr;
3400   Elf_Internal_Shdr *symstrtab_hdr;
3401   struct elf_backend_data *bed = get_elf_backend_data (abfd);
3402   struct elf_outext_info eoinfo;
3403
3404   if (info->shared)
3405     abfd->flags |= DYNAMIC;
3406
3407   dynamic = elf_hash_table (info)->dynamic_sections_created;
3408   dynobj = elf_hash_table (info)->dynobj;
3409
3410   finfo.info = info;
3411   finfo.output_bfd = abfd;
3412   finfo.symstrtab = elf_stringtab_init ();
3413   if (finfo.symstrtab == NULL)
3414     return false;
3415
3416   if (! dynamic)
3417     {
3418       finfo.dynsym_sec = NULL;
3419       finfo.hash_sec = NULL;
3420       finfo.symver_sec = NULL;
3421     }
3422   else
3423     {
3424       finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
3425       finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
3426       BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
3427       finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
3428       /* Note that it is OK if symver_sec is NULL.  */
3429     }
3430
3431   finfo.contents = NULL;
3432   finfo.external_relocs = NULL;
3433   finfo.internal_relocs = NULL;
3434   finfo.external_syms = NULL;
3435   finfo.internal_syms = NULL;
3436   finfo.indices = NULL;
3437   finfo.sections = NULL;
3438   finfo.symbuf = NULL;
3439   finfo.symbuf_count = 0;
3440
3441   /* Count up the number of relocations we will output for each output
3442      section, so that we know the sizes of the reloc sections.  We
3443      also figure out some maximum sizes.  */
3444   max_contents_size = 0;
3445   max_external_reloc_size = 0;
3446   max_internal_reloc_count = 0;
3447   max_sym_count = 0;
3448   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3449     {
3450       o->reloc_count = 0;
3451
3452       for (p = o->link_order_head; p != NULL; p = p->next)
3453         {
3454           if (p->type == bfd_section_reloc_link_order
3455               || p->type == bfd_symbol_reloc_link_order)
3456             ++o->reloc_count;
3457           else if (p->type == bfd_indirect_link_order)
3458             {
3459               asection *sec;
3460
3461               sec = p->u.indirect.section;
3462
3463               /* Mark all sections which are to be included in the
3464                  link.  This will normally be every section.  We need
3465                  to do this so that we can identify any sections which
3466                  the linker has decided to not include.  */
3467               sec->linker_mark = true;
3468
3469               if (info->relocateable)
3470                 o->reloc_count += sec->reloc_count;
3471
3472               if (sec->_raw_size > max_contents_size)
3473                 max_contents_size = sec->_raw_size;
3474               if (sec->_cooked_size > max_contents_size)
3475                 max_contents_size = sec->_cooked_size;
3476
3477               /* We are interested in just local symbols, not all
3478                  symbols.  */
3479               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
3480                   && (sec->owner->flags & DYNAMIC) == 0)
3481                 {
3482                   size_t sym_count;
3483
3484                   if (elf_bad_symtab (sec->owner))
3485                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
3486                                  / sizeof (Elf_External_Sym));
3487                   else
3488                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
3489
3490                   if (sym_count > max_sym_count)
3491                     max_sym_count = sym_count;
3492
3493                   if ((sec->flags & SEC_RELOC) != 0)
3494                     {
3495                       size_t ext_size;
3496
3497                       ext_size = elf_section_data (sec)->rel_hdr.sh_size;
3498                       if (ext_size > max_external_reloc_size)
3499                         max_external_reloc_size = ext_size;
3500                       if (sec->reloc_count > max_internal_reloc_count)
3501                         max_internal_reloc_count = sec->reloc_count;
3502                     }
3503                 }
3504             }
3505         }
3506
3507       if (o->reloc_count > 0)
3508         o->flags |= SEC_RELOC;
3509       else
3510         {
3511           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
3512              set it (this is probably a bug) and if it is set
3513              assign_section_numbers will create a reloc section.  */
3514           o->flags &=~ SEC_RELOC;
3515         }
3516
3517       /* If the SEC_ALLOC flag is not set, force the section VMA to
3518          zero.  This is done in elf_fake_sections as well, but forcing
3519          the VMA to 0 here will ensure that relocs against these
3520          sections are handled correctly.  */
3521       if ((o->flags & SEC_ALLOC) == 0
3522           && ! o->user_set_vma)
3523         o->vma = 0;
3524     }
3525
3526   /* Figure out the file positions for everything but the symbol table
3527      and the relocs.  We set symcount to force assign_section_numbers
3528      to create a symbol table.  */
3529   abfd->symcount = info->strip == strip_all ? 0 : 1;
3530   BFD_ASSERT (! abfd->output_has_begun);
3531   if (! _bfd_elf_compute_section_file_positions (abfd, info))
3532     goto error_return;
3533
3534   /* That created the reloc sections.  Set their sizes, and assign
3535      them file positions, and allocate some buffers.  */
3536   for (o = abfd->sections; o != NULL; o = o->next)
3537     {
3538       if ((o->flags & SEC_RELOC) != 0)
3539         {
3540           Elf_Internal_Shdr *rel_hdr;
3541           register struct elf_link_hash_entry **p, **pend;
3542
3543           rel_hdr = &elf_section_data (o)->rel_hdr;
3544
3545           rel_hdr->sh_size = rel_hdr->sh_entsize * o->reloc_count;
3546
3547           /* The contents field must last into write_object_contents,
3548              so we allocate it with bfd_alloc rather than malloc.  */
3549           rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
3550           if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
3551             goto error_return;
3552
3553           p = ((struct elf_link_hash_entry **)
3554                bfd_malloc (o->reloc_count
3555                            * sizeof (struct elf_link_hash_entry *)));
3556           if (p == NULL && o->reloc_count != 0)
3557             goto error_return;
3558           elf_section_data (o)->rel_hashes = p;
3559           pend = p + o->reloc_count;
3560           for (; p < pend; p++)
3561             *p = NULL;
3562
3563           /* Use the reloc_count field as an index when outputting the
3564              relocs.  */
3565           o->reloc_count = 0;
3566         }
3567     }
3568
3569   _bfd_elf_assign_file_positions_for_relocs (abfd);
3570
3571   /* We have now assigned file positions for all the sections except
3572      .symtab and .strtab.  We start the .symtab section at the current
3573      file position, and write directly to it.  We build the .strtab
3574      section in memory.  */
3575   abfd->symcount = 0;
3576   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3577   /* sh_name is set in prep_headers.  */
3578   symtab_hdr->sh_type = SHT_SYMTAB;
3579   symtab_hdr->sh_flags = 0;
3580   symtab_hdr->sh_addr = 0;
3581   symtab_hdr->sh_size = 0;
3582   symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
3583   /* sh_link is set in assign_section_numbers.  */
3584   /* sh_info is set below.  */
3585   /* sh_offset is set just below.  */
3586   symtab_hdr->sh_addralign = 4;  /* FIXME: system dependent?  */
3587
3588   off = elf_tdata (abfd)->next_file_pos;
3589   off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
3590
3591   /* Note that at this point elf_tdata (abfd)->next_file_pos is
3592      incorrect.  We do not yet know the size of the .symtab section.
3593      We correct next_file_pos below, after we do know the size.  */
3594
3595   /* Allocate a buffer to hold swapped out symbols.  This is to avoid
3596      continuously seeking to the right position in the file.  */
3597   if (! info->keep_memory || max_sym_count < 20)
3598     finfo.symbuf_size = 20;
3599   else
3600     finfo.symbuf_size = max_sym_count;
3601   finfo.symbuf = ((Elf_External_Sym *)
3602                   bfd_malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
3603   if (finfo.symbuf == NULL)
3604     goto error_return;
3605
3606   /* Start writing out the symbol table.  The first symbol is always a
3607      dummy symbol.  */
3608   if (info->strip != strip_all || info->relocateable)
3609     {
3610       elfsym.st_value = 0;
3611       elfsym.st_size = 0;
3612       elfsym.st_info = 0;
3613       elfsym.st_other = 0;
3614       elfsym.st_shndx = SHN_UNDEF;
3615       if (! elf_link_output_sym (&finfo, (const char *) NULL,
3616                                  &elfsym, bfd_und_section_ptr))
3617         goto error_return;
3618     }
3619
3620 #if 0
3621   /* Some standard ELF linkers do this, but we don't because it causes
3622      bootstrap comparison failures.  */
3623   /* Output a file symbol for the output file as the second symbol.
3624      We output this even if we are discarding local symbols, although
3625      I'm not sure if this is correct.  */
3626   elfsym.st_value = 0;
3627   elfsym.st_size = 0;
3628   elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
3629   elfsym.st_other = 0;
3630   elfsym.st_shndx = SHN_ABS;
3631   if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
3632                              &elfsym, bfd_abs_section_ptr))
3633     goto error_return;
3634 #endif
3635
3636   /* Output a symbol for each section.  We output these even if we are
3637      discarding local symbols, since they are used for relocs.  These
3638      symbols have no names.  We store the index of each one in the
3639      index field of the section, so that we can find it again when
3640      outputting relocs.  */
3641   if (info->strip != strip_all || info->relocateable)
3642     {
3643       elfsym.st_size = 0;
3644       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
3645       elfsym.st_other = 0;
3646       for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
3647         {
3648           o = section_from_elf_index (abfd, i);
3649           if (o != NULL)
3650             o->target_index = abfd->symcount;
3651           elfsym.st_shndx = i;
3652           if (info->relocateable || o == NULL)
3653             elfsym.st_value = 0;
3654           else
3655             elfsym.st_value = o->vma;
3656           if (! elf_link_output_sym (&finfo, (const char *) NULL,
3657                                      &elfsym, o))
3658             goto error_return;
3659         }
3660     }
3661
3662   /* Allocate some memory to hold information read in from the input
3663      files.  */
3664   finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
3665   finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
3666   finfo.internal_relocs = ((Elf_Internal_Rela *)
3667                            bfd_malloc (max_internal_reloc_count
3668                                        * sizeof (Elf_Internal_Rela)));
3669   finfo.external_syms = ((Elf_External_Sym *)
3670                          bfd_malloc (max_sym_count
3671                                      * sizeof (Elf_External_Sym)));
3672   finfo.internal_syms = ((Elf_Internal_Sym *)
3673                          bfd_malloc (max_sym_count
3674                                      * sizeof (Elf_Internal_Sym)));
3675   finfo.indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
3676   finfo.sections = ((asection **)
3677                     bfd_malloc (max_sym_count * sizeof (asection *)));
3678   if ((finfo.contents == NULL && max_contents_size != 0)
3679       || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
3680       || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
3681       || (finfo.external_syms == NULL && max_sym_count != 0)
3682       || (finfo.internal_syms == NULL && max_sym_count != 0)
3683       || (finfo.indices == NULL && max_sym_count != 0)
3684       || (finfo.sections == NULL && max_sym_count != 0))
3685     goto error_return;
3686
3687   /* Since ELF permits relocations to be against local symbols, we
3688      must have the local symbols available when we do the relocations.
3689      Since we would rather only read the local symbols once, and we
3690      would rather not keep them in memory, we handle all the
3691      relocations for a single input file at the same time.
3692
3693      Unfortunately, there is no way to know the total number of local
3694      symbols until we have seen all of them, and the local symbol
3695      indices precede the global symbol indices.  This means that when
3696      we are generating relocateable output, and we see a reloc against
3697      a global symbol, we can not know the symbol index until we have
3698      finished examining all the local symbols to see which ones we are
3699      going to output.  To deal with this, we keep the relocations in
3700      memory, and don't output them until the end of the link.  This is
3701      an unfortunate waste of memory, but I don't see a good way around
3702      it.  Fortunately, it only happens when performing a relocateable
3703      link, which is not the common case.  FIXME: If keep_memory is set
3704      we could write the relocs out and then read them again; I don't
3705      know how bad the memory loss will be.  */
3706
3707   for (sub = info->input_bfds; sub != NULL; sub = sub->next)
3708     sub->output_has_begun = false;
3709   for (o = abfd->sections; o != NULL; o = o->next)
3710     {
3711       for (p = o->link_order_head; p != NULL; p = p->next)
3712         {
3713           if (p->type == bfd_indirect_link_order
3714               && (bfd_get_flavour (p->u.indirect.section->owner)
3715                   == bfd_target_elf_flavour))
3716             {
3717               sub = p->u.indirect.section->owner;
3718               if (! sub->output_has_begun)
3719                 {
3720                   if (! elf_link_input_bfd (&finfo, sub))
3721                     goto error_return;
3722                   sub->output_has_begun = true;
3723                 }
3724             }
3725           else if (p->type == bfd_section_reloc_link_order
3726                    || p->type == bfd_symbol_reloc_link_order)
3727             {
3728               if (! elf_reloc_link_order (abfd, info, o, p))
3729                 goto error_return;
3730             }
3731           else
3732             {
3733               if (! _bfd_default_link_order (abfd, info, o, p))
3734                 goto error_return;
3735             }
3736         }
3737     }
3738
3739   /* That wrote out all the local symbols.  Finish up the symbol table
3740      with the global symbols.  */
3741
3742   if (info->strip != strip_all && info->shared)
3743     {
3744       /* Output any global symbols that got converted to local in a
3745          version script.  We do this in a separate step since ELF
3746          requires all local symbols to appear prior to any global
3747          symbols.  FIXME: We should only do this if some global
3748          symbols were, in fact, converted to become local.  FIXME:
3749          Will this work correctly with the Irix 5 linker?  */
3750       eoinfo.failed = false;
3751       eoinfo.finfo = &finfo;
3752       eoinfo.localsyms = true;
3753       elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
3754                               (PTR) &eoinfo);
3755       if (eoinfo.failed)
3756         return false;
3757     }
3758
3759   /* The sh_info field records the index of the first non local
3760      symbol.  */
3761   symtab_hdr->sh_info = abfd->symcount;
3762   if (dynamic)
3763     elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info = 1;
3764
3765   /* We get the global symbols from the hash table.  */
3766   eoinfo.failed = false;
3767   eoinfo.localsyms = false;
3768   eoinfo.finfo = &finfo;
3769   elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
3770                           (PTR) &eoinfo);
3771   if (eoinfo.failed)
3772     return false;
3773
3774   /* Flush all symbols to the file.  */
3775   if (! elf_link_flush_output_syms (&finfo))
3776     return false;
3777
3778   /* Now we know the size of the symtab section.  */
3779   off += symtab_hdr->sh_size;
3780
3781   /* Finish up and write out the symbol string table (.strtab)
3782      section.  */
3783   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
3784   /* sh_name was set in prep_headers.  */
3785   symstrtab_hdr->sh_type = SHT_STRTAB;
3786   symstrtab_hdr->sh_flags = 0;
3787   symstrtab_hdr->sh_addr = 0;
3788   symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
3789   symstrtab_hdr->sh_entsize = 0;
3790   symstrtab_hdr->sh_link = 0;
3791   symstrtab_hdr->sh_info = 0;
3792   /* sh_offset is set just below.  */
3793   symstrtab_hdr->sh_addralign = 1;
3794
3795   off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
3796   elf_tdata (abfd)->next_file_pos = off;
3797
3798   if (abfd->symcount > 0)
3799     {
3800       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
3801           || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
3802         return false;
3803     }
3804
3805   /* Adjust the relocs to have the correct symbol indices.  */
3806   for (o = abfd->sections; o != NULL; o = o->next)
3807     {
3808       struct elf_link_hash_entry **rel_hash;
3809       Elf_Internal_Shdr *rel_hdr;
3810
3811       if ((o->flags & SEC_RELOC) == 0)
3812         continue;
3813
3814       rel_hash = elf_section_data (o)->rel_hashes;
3815       rel_hdr = &elf_section_data (o)->rel_hdr;
3816       for (i = 0; i < o->reloc_count; i++, rel_hash++)
3817         {
3818           if (*rel_hash == NULL)
3819             continue;
3820
3821           BFD_ASSERT ((*rel_hash)->indx >= 0);
3822
3823           if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
3824             {
3825               Elf_External_Rel *erel;
3826               Elf_Internal_Rel irel;
3827
3828               erel = (Elf_External_Rel *) rel_hdr->contents + i;
3829               elf_swap_reloc_in (abfd, erel, &irel);
3830               irel.r_info = ELF_R_INFO ((*rel_hash)->indx,
3831                                         ELF_R_TYPE (irel.r_info));
3832               elf_swap_reloc_out (abfd, &irel, erel);
3833             }
3834           else
3835             {
3836               Elf_External_Rela *erela;
3837               Elf_Internal_Rela irela;
3838
3839               BFD_ASSERT (rel_hdr->sh_entsize
3840                           == sizeof (Elf_External_Rela));
3841
3842               erela = (Elf_External_Rela *) rel_hdr->contents + i;
3843               elf_swap_reloca_in (abfd, erela, &irela);
3844               irela.r_info = ELF_R_INFO ((*rel_hash)->indx,
3845                                          ELF_R_TYPE (irela.r_info));
3846               elf_swap_reloca_out (abfd, &irela, erela);
3847             }
3848         }
3849
3850       /* Set the reloc_count field to 0 to prevent write_relocs from
3851          trying to swap the relocs out itself.  */
3852       o->reloc_count = 0;
3853     }
3854
3855   /* If we are linking against a dynamic object, or generating a
3856      shared library, finish up the dynamic linking information.  */
3857   if (dynamic)
3858     {
3859       Elf_External_Dyn *dyncon, *dynconend;
3860
3861       /* Fix up .dynamic entries.  */
3862       o = bfd_get_section_by_name (dynobj, ".dynamic");
3863       BFD_ASSERT (o != NULL);
3864
3865       dyncon = (Elf_External_Dyn *) o->contents;
3866       dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
3867       for (; dyncon < dynconend; dyncon++)
3868         {
3869           Elf_Internal_Dyn dyn;
3870           const char *name;
3871           unsigned int type;
3872
3873           elf_swap_dyn_in (dynobj, dyncon, &dyn);
3874
3875           switch (dyn.d_tag)
3876             {
3877             default:
3878               break;
3879
3880               /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
3881                  magic _init and _fini symbols.  This is pretty ugly,
3882                  but we are compatible.  */
3883             case DT_INIT:
3884               name = "_init";
3885               goto get_sym;
3886             case DT_FINI:
3887               name = "_fini";
3888             get_sym:
3889               {
3890                 struct elf_link_hash_entry *h;
3891
3892                 h = elf_link_hash_lookup (elf_hash_table (info), name,
3893                                           false, false, true);
3894                 if (h != NULL
3895                     && (h->root.type == bfd_link_hash_defined
3896                         || h->root.type == bfd_link_hash_defweak))
3897                   {
3898                     dyn.d_un.d_val = h->root.u.def.value;
3899                     o = h->root.u.def.section;
3900                     if (o->output_section != NULL)
3901                       dyn.d_un.d_val += (o->output_section->vma
3902                                          + o->output_offset);
3903                     else
3904                       {
3905                         /* The symbol is imported from another shared
3906                            library and does not apply to this one.  */
3907                         dyn.d_un.d_val = 0;
3908                       }
3909
3910                     elf_swap_dyn_out (dynobj, &dyn, dyncon);
3911                   }
3912               }
3913               break;
3914
3915             case DT_HASH:
3916               name = ".hash";
3917               goto get_vma;
3918             case DT_STRTAB:
3919               name = ".dynstr";
3920               goto get_vma;
3921             case DT_SYMTAB:
3922               name = ".dynsym";
3923               goto get_vma;
3924             case DT_VERDEF:
3925               name = ".gnu.version_d";
3926               goto get_vma;
3927             case DT_VERNEED:
3928               name = ".gnu.version_r";
3929               goto get_vma;
3930             case DT_VERSYM:
3931               name = ".gnu.version";
3932             get_vma:
3933               o = bfd_get_section_by_name (abfd, name);
3934               BFD_ASSERT (o != NULL);
3935               dyn.d_un.d_ptr = o->vma;
3936               elf_swap_dyn_out (dynobj, &dyn, dyncon);
3937               break;
3938
3939             case DT_REL:
3940             case DT_RELA:
3941             case DT_RELSZ:
3942             case DT_RELASZ:
3943               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
3944                 type = SHT_REL;
3945               else
3946                 type = SHT_RELA;
3947               dyn.d_un.d_val = 0;
3948               for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
3949                 {
3950                   Elf_Internal_Shdr *hdr;
3951
3952                   hdr = elf_elfsections (abfd)[i];
3953                   if (hdr->sh_type == type
3954                       && (hdr->sh_flags & SHF_ALLOC) != 0)
3955                     {
3956                       if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
3957                         dyn.d_un.d_val += hdr->sh_size;
3958                       else
3959                         {
3960                           if (dyn.d_un.d_val == 0
3961                               || hdr->sh_addr < dyn.d_un.d_val)
3962                             dyn.d_un.d_val = hdr->sh_addr;
3963                         }
3964                     }
3965                 }
3966               elf_swap_dyn_out (dynobj, &dyn, dyncon);
3967               break;
3968             }
3969         }
3970     }
3971
3972   /* If we have created any dynamic sections, then output them.  */
3973   if (dynobj != NULL)
3974     {
3975       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
3976         goto error_return;
3977
3978       for (o = dynobj->sections; o != NULL; o = o->next)
3979         {
3980           if ((o->flags & SEC_HAS_CONTENTS) == 0
3981               || o->_raw_size == 0)
3982             continue;
3983           if ((o->flags & SEC_LINKER_CREATED) == 0)
3984             {
3985               /* At this point, we are only interested in sections
3986                  created by elf_link_create_dynamic_sections.  */
3987               continue;
3988             }
3989           if ((elf_section_data (o->output_section)->this_hdr.sh_type
3990                != SHT_STRTAB)
3991               || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
3992             {
3993               if (! bfd_set_section_contents (abfd, o->output_section,
3994                                               o->contents, o->output_offset,
3995                                               o->_raw_size))
3996                 goto error_return;
3997             }
3998           else
3999             {
4000               file_ptr off;
4001
4002               /* The contents of the .dynstr section are actually in a
4003                  stringtab.  */
4004               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
4005               if (bfd_seek (abfd, off, SEEK_SET) != 0
4006                   || ! _bfd_stringtab_emit (abfd,
4007                                             elf_hash_table (info)->dynstr))
4008                 goto error_return;
4009             }
4010         }
4011     }
4012
4013   /* If we have optimized stabs strings, output them.  */
4014   if (elf_hash_table (info)->stab_info != NULL)
4015     {
4016       if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
4017         goto error_return;
4018     }
4019
4020   if (finfo.symstrtab != NULL)
4021     _bfd_stringtab_free (finfo.symstrtab);
4022   if (finfo.contents != NULL)
4023     free (finfo.contents);
4024   if (finfo.external_relocs != NULL)
4025     free (finfo.external_relocs);
4026   if (finfo.internal_relocs != NULL)
4027     free (finfo.internal_relocs);
4028   if (finfo.external_syms != NULL)
4029     free (finfo.external_syms);
4030   if (finfo.internal_syms != NULL)
4031     free (finfo.internal_syms);
4032   if (finfo.indices != NULL)
4033     free (finfo.indices);
4034   if (finfo.sections != NULL)
4035     free (finfo.sections);
4036   if (finfo.symbuf != NULL)
4037     free (finfo.symbuf);
4038   for (o = abfd->sections; o != NULL; o = o->next)
4039     {
4040       if ((o->flags & SEC_RELOC) != 0
4041           && elf_section_data (o)->rel_hashes != NULL)
4042         free (elf_section_data (o)->rel_hashes);
4043     }
4044
4045   elf_tdata (abfd)->linker = true;
4046
4047   return true;
4048
4049  error_return:
4050   if (finfo.symstrtab != NULL)
4051     _bfd_stringtab_free (finfo.symstrtab);
4052   if (finfo.contents != NULL)
4053     free (finfo.contents);
4054   if (finfo.external_relocs != NULL)
4055     free (finfo.external_relocs);
4056   if (finfo.internal_relocs != NULL)
4057     free (finfo.internal_relocs);
4058   if (finfo.external_syms != NULL)
4059     free (finfo.external_syms);
4060   if (finfo.internal_syms != NULL)
4061     free (finfo.internal_syms);
4062   if (finfo.indices != NULL)
4063     free (finfo.indices);
4064   if (finfo.sections != NULL)
4065     free (finfo.sections);
4066   if (finfo.symbuf != NULL)
4067     free (finfo.symbuf);
4068   for (o = abfd->sections; o != NULL; o = o->next)
4069     {
4070       if ((o->flags & SEC_RELOC) != 0
4071           && elf_section_data (o)->rel_hashes != NULL)
4072         free (elf_section_data (o)->rel_hashes);
4073     }
4074
4075   return false;
4076 }
4077
4078 /* Add a symbol to the output symbol table.  */
4079
4080 static boolean
4081 elf_link_output_sym (finfo, name, elfsym, input_sec)
4082      struct elf_final_link_info *finfo;
4083      const char *name;
4084      Elf_Internal_Sym *elfsym;
4085      asection *input_sec;
4086 {
4087   boolean (*output_symbol_hook) PARAMS ((bfd *,
4088                                          struct bfd_link_info *info,
4089                                          const char *,
4090                                          Elf_Internal_Sym *,
4091                                          asection *));
4092
4093   output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
4094     elf_backend_link_output_symbol_hook;
4095   if (output_symbol_hook != NULL)
4096     {
4097       if (! ((*output_symbol_hook)
4098              (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
4099         return false;
4100     }
4101
4102   if (name == (const char *) NULL || *name == '\0')
4103     elfsym->st_name = 0;
4104   else
4105     {
4106       elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
4107                                                             name, true,
4108                                                             false);
4109       if (elfsym->st_name == (unsigned long) -1)
4110         return false;
4111     }
4112
4113   if (finfo->symbuf_count >= finfo->symbuf_size)
4114     {
4115       if (! elf_link_flush_output_syms (finfo))
4116         return false;
4117     }
4118
4119   elf_swap_symbol_out (finfo->output_bfd, elfsym,
4120                        (PTR) (finfo->symbuf + finfo->symbuf_count));
4121   ++finfo->symbuf_count;
4122
4123   ++finfo->output_bfd->symcount;
4124
4125   return true;
4126 }
4127
4128 /* Flush the output symbols to the file.  */
4129
4130 static boolean
4131 elf_link_flush_output_syms (finfo)
4132      struct elf_final_link_info *finfo;
4133 {
4134   if (finfo->symbuf_count > 0)
4135     {
4136       Elf_Internal_Shdr *symtab;
4137
4138       symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
4139
4140       if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
4141                     SEEK_SET) != 0
4142           || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
4143                          sizeof (Elf_External_Sym), finfo->output_bfd)
4144               != finfo->symbuf_count * sizeof (Elf_External_Sym)))
4145         return false;
4146
4147       symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
4148
4149       finfo->symbuf_count = 0;
4150     }
4151
4152   return true;
4153 }
4154
4155 /* Add an external symbol to the symbol table.  This is called from
4156    the hash table traversal routine.  When generating a shared object,
4157    we go through the symbol table twice.  The first time we output
4158    anything that might have been forced to local scope in a version
4159    script.  The second time we output the symbols that are still
4160    global symbols.  */
4161
4162 static boolean
4163 elf_link_output_extsym (h, data)
4164      struct elf_link_hash_entry *h;
4165      PTR data;
4166 {
4167   struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
4168   struct elf_final_link_info *finfo = eoinfo->finfo;
4169   boolean strip;
4170   Elf_Internal_Sym sym;
4171   asection *input_sec;
4172
4173   /* Decide whether to output this symbol in this pass.  */
4174   if (eoinfo->localsyms)
4175     {
4176       if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4177         return true;
4178     }
4179   else
4180     {
4181       if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
4182         return true;
4183     }
4184
4185   /* If we are not creating a shared library, and this symbol is
4186      referenced by a shared library but is not defined anywhere, then
4187      warn that it is undefined.  If we do not do this, the runtime
4188      linker will complain that the symbol is undefined when the
4189      program is run.  We don't have to worry about symbols that are
4190      referenced by regular files, because we will already have issued
4191      warnings for them.  */
4192   if (! finfo->info->relocateable
4193       && ! finfo->info->shared
4194       && h->root.type == bfd_link_hash_undefined
4195       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
4196       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
4197     {
4198       if (! ((*finfo->info->callbacks->undefined_symbol)
4199              (finfo->info, h->root.root.string, h->root.u.undef.abfd,
4200               (asection *) NULL, 0)))
4201         {
4202           eoinfo->failed = true;
4203           return false;
4204         }
4205     }
4206
4207   /* We don't want to output symbols that have never been mentioned by
4208      a regular file, or that we have been told to strip.  However, if
4209      h->indx is set to -2, the symbol is used by a reloc and we must
4210      output it.  */
4211   if (h->indx == -2)
4212     strip = false;
4213   else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4214             || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
4215            && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
4216            && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
4217     strip = true;
4218   else if (finfo->info->strip == strip_all
4219            || (finfo->info->strip == strip_some
4220                && bfd_hash_lookup (finfo->info->keep_hash,
4221                                    h->root.root.string,
4222                                    false, false) == NULL))
4223     strip = true;
4224   else
4225     strip = false;
4226
4227   /* If we're stripping it, and it's not a dynamic symbol, there's
4228      nothing else to do.  */
4229   if (strip && h->dynindx == -1)
4230     return true;
4231
4232   sym.st_value = 0;
4233   sym.st_size = h->size;
4234   sym.st_other = h->other;
4235   if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
4236     sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
4237   else if (h->root.type == bfd_link_hash_undefweak
4238            || h->root.type == bfd_link_hash_defweak)
4239     sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
4240   else
4241     sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
4242
4243   switch (h->root.type)
4244     {
4245     default:
4246     case bfd_link_hash_new:
4247       abort ();
4248       return false;
4249
4250     case bfd_link_hash_undefined:
4251       input_sec = bfd_und_section_ptr;
4252       sym.st_shndx = SHN_UNDEF;
4253       break;
4254
4255     case bfd_link_hash_undefweak:
4256       input_sec = bfd_und_section_ptr;
4257       sym.st_shndx = SHN_UNDEF;
4258       break;
4259
4260     case bfd_link_hash_defined:
4261     case bfd_link_hash_defweak:
4262       {
4263         input_sec = h->root.u.def.section;
4264         if (input_sec->output_section != NULL)
4265           {
4266             sym.st_shndx =
4267               _bfd_elf_section_from_bfd_section (finfo->output_bfd,
4268                                                  input_sec->output_section);
4269             if (sym.st_shndx == (unsigned short) -1)
4270               {
4271                 eoinfo->failed = true;
4272                 return false;
4273               }
4274
4275             /* ELF symbols in relocateable files are section relative,
4276                but in nonrelocateable files they are virtual
4277                addresses.  */
4278             sym.st_value = h->root.u.def.value + input_sec->output_offset;
4279             if (! finfo->info->relocateable)
4280               sym.st_value += input_sec->output_section->vma;
4281           }
4282         else
4283           {
4284             BFD_ASSERT (input_sec->owner == NULL
4285                         || (input_sec->owner->flags & DYNAMIC) != 0);
4286             sym.st_shndx = SHN_UNDEF;
4287             input_sec = bfd_und_section_ptr;
4288           }
4289       }
4290       break;
4291
4292     case bfd_link_hash_common:
4293       input_sec = h->root.u.c.p->section;
4294       sym.st_shndx = SHN_COMMON;
4295       sym.st_value = 1 << h->root.u.c.p->alignment_power;
4296       break;
4297
4298     case bfd_link_hash_indirect:
4299       /* These symbols are created by symbol versioning.  They point
4300          to the decorated version of the name.  For example, if the
4301          symbol foo@@GNU_1.2 is the default, which should be used when
4302          foo is used with no version, then we add an indirect symbol
4303          foo which points to foo@@GNU_1.2.  We ignore these symbols,
4304          since the indirected symbol is already in the hash table.  If
4305          the indirect symbol is non-ELF, fall through and output it.  */
4306       if ((h->elf_link_hash_flags & ELF_LINK_NON_ELF) == 0)
4307         return true;
4308
4309       /* Fall through.  */
4310     case bfd_link_hash_warning:
4311       /* We can't represent these symbols in ELF, although a warning
4312          symbol may have come from a .gnu.warning.SYMBOL section.  We
4313          just put the target symbol in the hash table.  If the target
4314          symbol does not really exist, don't do anything.  */
4315       if (h->root.u.i.link->type == bfd_link_hash_new)
4316         return true;
4317       return (elf_link_output_extsym
4318               ((struct elf_link_hash_entry *) h->root.u.i.link, data));
4319     }
4320
4321   /* Give the processor backend a chance to tweak the symbol value,
4322      and also to finish up anything that needs to be done for this
4323      symbol.  */
4324   if ((h->dynindx != -1
4325        || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
4326       && elf_hash_table (finfo->info)->dynamic_sections_created)
4327     {
4328       struct elf_backend_data *bed;
4329
4330       bed = get_elf_backend_data (finfo->output_bfd);
4331       if (! ((*bed->elf_backend_finish_dynamic_symbol)
4332              (finfo->output_bfd, finfo->info, h, &sym)))
4333         {
4334           eoinfo->failed = true;
4335           return false;
4336         }
4337     }
4338
4339   /* If this symbol should be put in the .dynsym section, then put it
4340      there now.  We have already know the symbol index.  We also fill
4341      in the entry in the .hash section.  */
4342   if (h->dynindx != -1
4343       && elf_hash_table (finfo->info)->dynamic_sections_created)
4344     {
4345       char *p, *copy;
4346       const char *name;
4347       size_t bucketcount;
4348       size_t bucket;
4349       bfd_byte *bucketpos;
4350       bfd_vma chain;
4351
4352       sym.st_name = h->dynstr_index;
4353
4354       elf_swap_symbol_out (finfo->output_bfd, &sym,
4355                            (PTR) (((Elf_External_Sym *)
4356                                    finfo->dynsym_sec->contents)
4357                                   + h->dynindx));
4358
4359       /* We didn't include the version string in the dynamic string
4360          table, so we must not consider it in the hash table.  */
4361       name = h->root.root.string;
4362       p = strchr (name, ELF_VER_CHR);
4363       if (p == NULL)
4364         copy = NULL;
4365       else
4366         {
4367           copy = bfd_alloc (finfo->output_bfd, p - name + 1);
4368           strncpy (copy, name, p - name);
4369           copy[p - name] = '\0';
4370           name = copy;
4371         }
4372
4373       bucketcount = elf_hash_table (finfo->info)->bucketcount;
4374       bucket = bfd_elf_hash ((const unsigned char *) name) % bucketcount;
4375       bucketpos = ((bfd_byte *) finfo->hash_sec->contents
4376                    + (bucket + 2) * (ARCH_SIZE / 8));
4377       chain = get_word (finfo->output_bfd, bucketpos);
4378       put_word (finfo->output_bfd, h->dynindx, bucketpos);
4379       put_word (finfo->output_bfd, chain,
4380                 ((bfd_byte *) finfo->hash_sec->contents
4381                  + (bucketcount + 2 + h->dynindx) * (ARCH_SIZE / 8)));
4382
4383       if (copy != NULL)
4384         bfd_release (finfo->output_bfd, copy);
4385
4386       if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
4387         {
4388           Elf_Internal_Versym iversym;
4389
4390           if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4391             {
4392               if (h->verinfo.verdef == NULL)
4393                 iversym.vs_vers = 0;
4394               else
4395                 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
4396             }
4397           else
4398             {
4399               if (h->verinfo.vertree == NULL)
4400                 iversym.vs_vers = 1;
4401               else
4402                 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
4403             }
4404
4405           if ((h->elf_link_hash_flags & ELF_LINK_HIDDEN) != 0)
4406             iversym.vs_vers |= VERSYM_HIDDEN;
4407
4408           _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym,
4409                                     (((Elf_External_Versym *)
4410                                       finfo->symver_sec->contents)
4411                                      + h->dynindx));
4412         }
4413     }
4414
4415   /* If we're stripping it, then it was just a dynamic symbol, and
4416      there's nothing else to do.  */
4417   if (strip)
4418     return true;
4419
4420   h->indx = finfo->output_bfd->symcount;
4421
4422   if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
4423     {
4424       eoinfo->failed = true;
4425       return false;
4426     }
4427
4428   return true;
4429 }
4430
4431 /* Link an input file into the linker output file.  This function
4432    handles all the sections and relocations of the input file at once.
4433    This is so that we only have to read the local symbols once, and
4434    don't have to keep them in memory.  */
4435
4436 static boolean
4437 elf_link_input_bfd (finfo, input_bfd)
4438      struct elf_final_link_info *finfo;
4439      bfd *input_bfd;
4440 {
4441   boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
4442                                        bfd *, asection *, bfd_byte *,
4443                                        Elf_Internal_Rela *,
4444                                        Elf_Internal_Sym *, asection **));
4445   bfd *output_bfd;
4446   Elf_Internal_Shdr *symtab_hdr;
4447   size_t locsymcount;
4448   size_t extsymoff;
4449   Elf_External_Sym *external_syms;
4450   Elf_External_Sym *esym;
4451   Elf_External_Sym *esymend;
4452   Elf_Internal_Sym *isym;
4453   long *pindex;
4454   asection **ppsection;
4455   asection *o;
4456
4457   output_bfd = finfo->output_bfd;
4458   relocate_section =
4459     get_elf_backend_data (output_bfd)->elf_backend_relocate_section;
4460
4461   /* If this is a dynamic object, we don't want to do anything here:
4462      we don't want the local symbols, and we don't want the section
4463      contents.  */
4464   if ((input_bfd->flags & DYNAMIC) != 0)
4465     return true;
4466
4467   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4468   if (elf_bad_symtab (input_bfd))
4469     {
4470       locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
4471       extsymoff = 0;
4472     }
4473   else
4474     {
4475       locsymcount = symtab_hdr->sh_info;
4476       extsymoff = symtab_hdr->sh_info;
4477     }
4478
4479   /* Read the local symbols.  */
4480   if (symtab_hdr->contents != NULL)
4481     external_syms = (Elf_External_Sym *) symtab_hdr->contents;
4482   else if (locsymcount == 0)
4483     external_syms = NULL;
4484   else
4485     {
4486       external_syms = finfo->external_syms;
4487       if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
4488           || (bfd_read (external_syms, sizeof (Elf_External_Sym),
4489                         locsymcount, input_bfd)
4490               != locsymcount * sizeof (Elf_External_Sym)))
4491         return false;
4492     }
4493
4494   /* Swap in the local symbols and write out the ones which we know
4495      are going into the output file.  */
4496   esym = external_syms;
4497   esymend = esym + locsymcount;
4498   isym = finfo->internal_syms;
4499   pindex = finfo->indices;
4500   ppsection = finfo->sections;
4501   for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
4502     {
4503       asection *isec;
4504       const char *name;
4505       Elf_Internal_Sym osym;
4506
4507       elf_swap_symbol_in (input_bfd, esym, isym);
4508       *pindex = -1;
4509
4510       if (elf_bad_symtab (input_bfd))
4511         {
4512           if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
4513             {
4514               *ppsection = NULL;
4515               continue;
4516             }
4517         }
4518
4519       if (isym->st_shndx == SHN_UNDEF)
4520         isec = bfd_und_section_ptr;
4521       else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
4522         isec = section_from_elf_index (input_bfd, isym->st_shndx);
4523       else if (isym->st_shndx == SHN_ABS)
4524         isec = bfd_abs_section_ptr;
4525       else if (isym->st_shndx == SHN_COMMON)
4526         isec = bfd_com_section_ptr;
4527       else
4528         {
4529           /* Who knows?  */
4530           isec = NULL;
4531         }
4532
4533       *ppsection = isec;
4534
4535       /* Don't output the first, undefined, symbol.  */
4536       if (esym == external_syms)
4537         continue;
4538
4539       /* If we are stripping all symbols, we don't want to output this
4540          one.  */
4541       if (finfo->info->strip == strip_all)
4542         continue;
4543
4544       /* We never output section symbols.  Instead, we use the section
4545          symbol of the corresponding section in the output file.  */
4546       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
4547         continue;
4548
4549       /* If we are discarding all local symbols, we don't want to
4550          output this one.  If we are generating a relocateable output
4551          file, then some of the local symbols may be required by
4552          relocs; we output them below as we discover that they are
4553          needed.  */
4554       if (finfo->info->discard == discard_all)
4555         continue;
4556
4557       /* If this symbol is defined in a section which we are
4558          discarding, we don't need to keep it, but note that
4559          linker_mark is only reliable for sections that have contents.
4560          For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
4561          as well as linker_mark.  */
4562       if (isym->st_shndx > 0
4563           && isym->st_shndx < SHN_LORESERVE
4564           && isec != NULL
4565           && ((! isec->linker_mark && (isec->flags & SEC_HAS_CONTENTS) != 0)
4566               || (! finfo->info->relocateable
4567                   && (isec->flags & SEC_EXCLUDE) != 0)))
4568         continue;
4569
4570       /* Get the name of the symbol.  */
4571       name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
4572                                               isym->st_name);
4573       if (name == NULL)
4574         return false;
4575
4576       /* See if we are discarding symbols with this name.  */
4577       if ((finfo->info->strip == strip_some
4578            && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
4579                == NULL))
4580           || (finfo->info->discard == discard_l
4581               && bfd_is_local_label_name (input_bfd, name)))
4582         continue;
4583
4584       /* If we get here, we are going to output this symbol.  */
4585
4586       osym = *isym;
4587
4588       /* Adjust the section index for the output file.  */
4589       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
4590                                                          isec->output_section);
4591       if (osym.st_shndx == (unsigned short) -1)
4592         return false;
4593
4594       *pindex = output_bfd->symcount;
4595
4596       /* ELF symbols in relocateable files are section relative, but
4597          in executable files they are virtual addresses.  Note that
4598          this code assumes that all ELF sections have an associated
4599          BFD section with a reasonable value for output_offset; below
4600          we assume that they also have a reasonable value for
4601          output_section.  Any special sections must be set up to meet
4602          these requirements.  */
4603       osym.st_value += isec->output_offset;
4604       if (! finfo->info->relocateable)
4605         osym.st_value += isec->output_section->vma;
4606
4607       if (! elf_link_output_sym (finfo, name, &osym, isec))
4608         return false;
4609     }
4610
4611   /* Relocate the contents of each section.  */
4612   for (o = input_bfd->sections; o != NULL; o = o->next)
4613     {
4614       bfd_byte *contents;
4615
4616       if (! o->linker_mark)
4617         {
4618           /* This section was omitted from the link.  */
4619           continue;
4620         }
4621
4622       if ((o->flags & SEC_HAS_CONTENTS) == 0
4623           || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
4624         continue;
4625
4626       if ((o->flags & SEC_LINKER_CREATED) != 0)
4627         {
4628           /* Section was created by elf_link_create_dynamic_sections
4629              or somesuch.  */
4630           continue;
4631         }
4632
4633       /* Get the contents of the section.  They have been cached by a
4634          relaxation routine.  Note that o is a section in an input
4635          file, so the contents field will not have been set by any of
4636          the routines which work on output files.  */
4637       if (elf_section_data (o)->this_hdr.contents != NULL)
4638         contents = elf_section_data (o)->this_hdr.contents;
4639       else
4640         {
4641           contents = finfo->contents;
4642           if (! bfd_get_section_contents (input_bfd, o, contents,
4643                                           (file_ptr) 0, o->_raw_size))
4644             return false;
4645         }
4646
4647       if ((o->flags & SEC_RELOC) != 0)
4648         {
4649           Elf_Internal_Rela *internal_relocs;
4650
4651           /* Get the swapped relocs.  */
4652           internal_relocs = (NAME(_bfd_elf,link_read_relocs)
4653                              (input_bfd, o, finfo->external_relocs,
4654                               finfo->internal_relocs, false));
4655           if (internal_relocs == NULL
4656               && o->reloc_count > 0)
4657             return false;
4658
4659           /* Relocate the section by invoking a back end routine.
4660
4661              The back end routine is responsible for adjusting the
4662              section contents as necessary, and (if using Rela relocs
4663              and generating a relocateable output file) adjusting the
4664              reloc addend as necessary.
4665
4666              The back end routine does not have to worry about setting
4667              the reloc address or the reloc symbol index.
4668
4669              The back end routine is given a pointer to the swapped in
4670              internal symbols, and can access the hash table entries
4671              for the external symbols via elf_sym_hashes (input_bfd).
4672
4673              When generating relocateable output, the back end routine
4674              must handle STB_LOCAL/STT_SECTION symbols specially.  The
4675              output symbol is going to be a section symbol
4676              corresponding to the output section, which will require
4677              the addend to be adjusted.  */
4678
4679           if (! (*relocate_section) (output_bfd, finfo->info,
4680                                      input_bfd, o, contents,
4681                                      internal_relocs,
4682                                      finfo->internal_syms,
4683                                      finfo->sections))
4684             return false;
4685
4686           if (finfo->info->relocateable)
4687             {
4688               Elf_Internal_Rela *irela;
4689               Elf_Internal_Rela *irelaend;
4690               struct elf_link_hash_entry **rel_hash;
4691               Elf_Internal_Shdr *input_rel_hdr;
4692               Elf_Internal_Shdr *output_rel_hdr;
4693
4694               /* Adjust the reloc addresses and symbol indices.  */
4695
4696               irela = internal_relocs;
4697               irelaend = irela + o->reloc_count;
4698               rel_hash = (elf_section_data (o->output_section)->rel_hashes
4699                           + o->output_section->reloc_count);
4700               for (; irela < irelaend; irela++, rel_hash++)
4701                 {
4702                   unsigned long r_symndx;
4703                   Elf_Internal_Sym *isym;
4704                   asection *sec;
4705
4706                   irela->r_offset += o->output_offset;
4707
4708                   r_symndx = ELF_R_SYM (irela->r_info);
4709
4710                   if (r_symndx == 0)
4711                     continue;
4712
4713                   if (r_symndx >= locsymcount
4714                       || (elf_bad_symtab (input_bfd)
4715                           && finfo->sections[r_symndx] == NULL))
4716                     {
4717                       long indx;
4718
4719                       /* This is a reloc against a global symbol.  We
4720                          have not yet output all the local symbols, so
4721                          we do not know the symbol index of any global
4722                          symbol.  We set the rel_hash entry for this
4723                          reloc to point to the global hash table entry
4724                          for this symbol.  The symbol index is then
4725                          set at the end of elf_bfd_final_link.  */
4726                       indx = r_symndx - extsymoff;
4727                       *rel_hash = elf_sym_hashes (input_bfd)[indx];
4728
4729                       /* Setting the index to -2 tells
4730                          elf_link_output_extsym that this symbol is
4731                          used by a reloc.  */
4732                       BFD_ASSERT ((*rel_hash)->indx < 0);
4733                       (*rel_hash)->indx = -2;
4734
4735                       continue;
4736                     }
4737
4738                   /* This is a reloc against a local symbol. */
4739
4740                   *rel_hash = NULL;
4741                   isym = finfo->internal_syms + r_symndx;
4742                   sec = finfo->sections[r_symndx];
4743                   if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
4744                     {
4745                       /* I suppose the backend ought to fill in the
4746                          section of any STT_SECTION symbol against a
4747                          processor specific section.  If we have
4748                          discarded a section, the output_section will
4749                          be the absolute section.  */
4750                       if (sec != NULL
4751                           && (bfd_is_abs_section (sec)
4752                               || (sec->output_section != NULL
4753                                   && bfd_is_abs_section (sec->output_section))))
4754                         r_symndx = 0;
4755                       else if (sec == NULL || sec->owner == NULL)
4756                         {
4757                           bfd_set_error (bfd_error_bad_value);
4758                           return false;
4759                         }
4760                       else
4761                         {
4762                           r_symndx = sec->output_section->target_index;
4763                           BFD_ASSERT (r_symndx != 0);
4764                         }
4765                     }
4766                   else
4767                     {
4768                       if (finfo->indices[r_symndx] == -1)
4769                         {
4770                           unsigned long link;
4771                           const char *name;
4772                           asection *osec;
4773
4774                           if (finfo->info->strip == strip_all)
4775                             {
4776                               /* You can't do ld -r -s.  */
4777                               bfd_set_error (bfd_error_invalid_operation);
4778                               return false;
4779                             }
4780
4781                           /* This symbol was skipped earlier, but
4782                              since it is needed by a reloc, we
4783                              must output it now.  */
4784                           link = symtab_hdr->sh_link;
4785                           name = bfd_elf_string_from_elf_section (input_bfd,
4786                                                                   link,
4787                                                                   isym->st_name);
4788                           if (name == NULL)
4789                             return false;
4790
4791                           osec = sec->output_section;
4792                           isym->st_shndx =
4793                             _bfd_elf_section_from_bfd_section (output_bfd,
4794                                                                osec);
4795                           if (isym->st_shndx == (unsigned short) -1)
4796                             return false;
4797
4798                           isym->st_value += sec->output_offset;
4799                           if (! finfo->info->relocateable)
4800                             isym->st_value += osec->vma;
4801
4802                           finfo->indices[r_symndx] = output_bfd->symcount;
4803
4804                           if (! elf_link_output_sym (finfo, name, isym, sec))
4805                             return false;
4806                         }
4807
4808                       r_symndx = finfo->indices[r_symndx];
4809                     }
4810
4811                   irela->r_info = ELF_R_INFO (r_symndx,
4812                                               ELF_R_TYPE (irela->r_info));
4813                 }
4814
4815               /* Swap out the relocs.  */
4816               input_rel_hdr = &elf_section_data (o)->rel_hdr;
4817               output_rel_hdr = &elf_section_data (o->output_section)->rel_hdr;
4818               BFD_ASSERT (output_rel_hdr->sh_entsize
4819                           == input_rel_hdr->sh_entsize);
4820               irela = internal_relocs;
4821               irelaend = irela + o->reloc_count;
4822               if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
4823                 {
4824                   Elf_External_Rel *erel;
4825
4826                   erel = ((Elf_External_Rel *) output_rel_hdr->contents
4827                           + o->output_section->reloc_count);
4828                   for (; irela < irelaend; irela++, erel++)
4829                     {
4830                       Elf_Internal_Rel irel;
4831
4832                       irel.r_offset = irela->r_offset;
4833                       irel.r_info = irela->r_info;
4834                       BFD_ASSERT (irela->r_addend == 0);
4835                       elf_swap_reloc_out (output_bfd, &irel, erel);
4836                     }
4837                 }
4838               else
4839                 {
4840                   Elf_External_Rela *erela;
4841
4842                   BFD_ASSERT (input_rel_hdr->sh_entsize
4843                               == sizeof (Elf_External_Rela));
4844                   erela = ((Elf_External_Rela *) output_rel_hdr->contents
4845                            + o->output_section->reloc_count);
4846                   for (; irela < irelaend; irela++, erela++)
4847                     elf_swap_reloca_out (output_bfd, irela, erela);
4848                 }
4849
4850               o->output_section->reloc_count += o->reloc_count;
4851             }
4852         }
4853
4854       /* Write out the modified section contents.  */
4855       if (elf_section_data (o)->stab_info == NULL)
4856         {
4857           if (! bfd_set_section_contents (output_bfd, o->output_section,
4858                                           contents, o->output_offset,
4859                                           (o->_cooked_size != 0
4860                                            ? o->_cooked_size
4861                                            : o->_raw_size)))
4862             return false;
4863         }
4864       else
4865         {
4866           if (! (_bfd_write_section_stabs
4867                  (output_bfd, &elf_hash_table (finfo->info)->stab_info,
4868                   o, &elf_section_data (o)->stab_info, contents)))
4869             return false;
4870         }
4871     }
4872
4873   return true;
4874 }
4875
4876 /* Generate a reloc when linking an ELF file.  This is a reloc
4877    requested by the linker, and does come from any input file.  This
4878    is used to build constructor and destructor tables when linking
4879    with -Ur.  */
4880
4881 static boolean
4882 elf_reloc_link_order (output_bfd, info, output_section, link_order)
4883      bfd *output_bfd;
4884      struct bfd_link_info *info;
4885      asection *output_section;
4886      struct bfd_link_order *link_order;
4887 {
4888   reloc_howto_type *howto;
4889   long indx;
4890   bfd_vma offset;
4891   bfd_vma addend;
4892   struct elf_link_hash_entry **rel_hash_ptr;
4893   Elf_Internal_Shdr *rel_hdr;
4894
4895   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
4896   if (howto == NULL)
4897     {
4898       bfd_set_error (bfd_error_bad_value);
4899       return false;
4900     }
4901
4902   addend = link_order->u.reloc.p->addend;
4903
4904   /* Figure out the symbol index.  */
4905   rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
4906                   + output_section->reloc_count);
4907   if (link_order->type == bfd_section_reloc_link_order)
4908     {
4909       indx = link_order->u.reloc.p->u.section->target_index;
4910       BFD_ASSERT (indx != 0);
4911       *rel_hash_ptr = NULL;
4912     }
4913   else
4914     {
4915       struct elf_link_hash_entry *h;
4916
4917       /* Treat a reloc against a defined symbol as though it were
4918          actually against the section.  */
4919       h = ((struct elf_link_hash_entry *)
4920            bfd_wrapped_link_hash_lookup (output_bfd, info,
4921                                          link_order->u.reloc.p->u.name,
4922                                          false, false, true));
4923       if (h != NULL
4924           && (h->root.type == bfd_link_hash_defined
4925               || h->root.type == bfd_link_hash_defweak))
4926         {
4927           asection *section;
4928
4929           section = h->root.u.def.section;
4930           indx = section->output_section->target_index;
4931           *rel_hash_ptr = NULL;
4932           /* It seems that we ought to add the symbol value to the
4933              addend here, but in practice it has already been added
4934              because it was passed to constructor_callback.  */
4935           addend += section->output_section->vma + section->output_offset;
4936         }
4937       else if (h != NULL)
4938         {
4939           /* Setting the index to -2 tells elf_link_output_extsym that
4940              this symbol is used by a reloc.  */
4941           h->indx = -2;
4942           *rel_hash_ptr = h;
4943           indx = 0;
4944         }
4945       else
4946         {
4947           if (! ((*info->callbacks->unattached_reloc)
4948                  (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
4949                   (asection *) NULL, (bfd_vma) 0)))
4950             return false;
4951           indx = 0;
4952         }
4953     }
4954
4955   /* If this is an inplace reloc, we must write the addend into the
4956      object file.  */
4957   if (howto->partial_inplace && addend != 0)
4958     {
4959       bfd_size_type size;
4960       bfd_reloc_status_type rstat;
4961       bfd_byte *buf;
4962       boolean ok;
4963
4964       size = bfd_get_reloc_size (howto);
4965       buf = (bfd_byte *) bfd_zmalloc (size);
4966       if (buf == (bfd_byte *) NULL)
4967         return false;
4968       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
4969       switch (rstat)
4970         {
4971         case bfd_reloc_ok:
4972           break;
4973         default:
4974         case bfd_reloc_outofrange:
4975           abort ();
4976         case bfd_reloc_overflow:
4977           if (! ((*info->callbacks->reloc_overflow)
4978                  (info,
4979                   (link_order->type == bfd_section_reloc_link_order
4980                    ? bfd_section_name (output_bfd,
4981                                        link_order->u.reloc.p->u.section)
4982                    : link_order->u.reloc.p->u.name),
4983                   howto->name, addend, (bfd *) NULL, (asection *) NULL,
4984                   (bfd_vma) 0)))
4985             {
4986               free (buf);
4987               return false;
4988             }
4989           break;
4990         }
4991       ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
4992                                      (file_ptr) link_order->offset, size);
4993       free (buf);
4994       if (! ok)
4995         return false;
4996     }
4997
4998   /* The address of a reloc is relative to the section in a
4999      relocateable file, and is a virtual address in an executable
5000      file.  */
5001   offset = link_order->offset;
5002   if (! info->relocateable)
5003     offset += output_section->vma;
5004
5005   rel_hdr = &elf_section_data (output_section)->rel_hdr;
5006
5007   if (rel_hdr->sh_type == SHT_REL)
5008     {
5009       Elf_Internal_Rel irel;
5010       Elf_External_Rel *erel;
5011
5012       irel.r_offset = offset;
5013       irel.r_info = ELF_R_INFO (indx, howto->type);
5014       erel = ((Elf_External_Rel *) rel_hdr->contents
5015               + output_section->reloc_count);
5016       elf_swap_reloc_out (output_bfd, &irel, erel);
5017     }
5018   else
5019     {
5020       Elf_Internal_Rela irela;
5021       Elf_External_Rela *erela;
5022
5023       irela.r_offset = offset;
5024       irela.r_info = ELF_R_INFO (indx, howto->type);
5025       irela.r_addend = addend;
5026       erela = ((Elf_External_Rela *) rel_hdr->contents
5027                + output_section->reloc_count);
5028       elf_swap_reloca_out (output_bfd, &irela, erela);
5029     }
5030
5031   ++output_section->reloc_count;
5032
5033   return true;
5034 }
5035
5036 \f
5037 /* Allocate a pointer to live in a linker created section.  */
5038
5039 boolean
5040 elf_create_pointer_linker_section (abfd, info, lsect, h, rel)
5041      bfd *abfd;
5042      struct bfd_link_info *info;
5043      elf_linker_section_t *lsect;
5044      struct elf_link_hash_entry *h;
5045      const Elf_Internal_Rela *rel;
5046 {
5047   elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
5048   elf_linker_section_pointers_t *linker_section_ptr;
5049   unsigned long r_symndx = ELF_R_SYM (rel->r_info);;
5050
5051   BFD_ASSERT (lsect != NULL);
5052
5053   /* Is this a global symbol? */
5054   if (h != NULL)
5055     {
5056       /* Has this symbol already been allocated, if so, our work is done */
5057       if (_bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
5058                                                 rel->r_addend,
5059                                                 lsect->which))
5060         return true;
5061
5062       ptr_linker_section_ptr = &h->linker_section_pointer;
5063       /* Make sure this symbol is output as a dynamic symbol.  */
5064       if (h->dynindx == -1)
5065         {
5066           if (! elf_link_record_dynamic_symbol (info, h))
5067             return false;
5068         }
5069
5070       if (lsect->rel_section)
5071         lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
5072     }
5073
5074   else  /* Allocation of a pointer to a local symbol */
5075     {
5076       elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
5077
5078       /* Allocate a table to hold the local symbols if first time */
5079       if (!ptr)
5080         {
5081           int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info;
5082           register unsigned int i;
5083
5084           ptr = (elf_linker_section_pointers_t **)
5085             bfd_alloc (abfd, num_symbols * sizeof (elf_linker_section_pointers_t *));
5086
5087           if (!ptr)
5088             return false;
5089
5090           elf_local_ptr_offsets (abfd) = ptr;
5091           for (i = 0; i < num_symbols; i++)
5092             ptr[i] = (elf_linker_section_pointers_t *)0;
5093         }
5094
5095       /* Has this symbol already been allocated, if so, our work is done */
5096       if (_bfd_elf_find_pointer_linker_section (ptr[r_symndx],
5097                                                 rel->r_addend,
5098                                                 lsect->which))
5099         return true;
5100
5101       ptr_linker_section_ptr = &ptr[r_symndx];
5102
5103       if (info->shared)
5104         {
5105           /* If we are generating a shared object, we need to
5106              output a R_<xxx>_RELATIVE reloc so that the
5107              dynamic linker can adjust this GOT entry.  */
5108           BFD_ASSERT (lsect->rel_section != NULL);
5109           lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
5110         }
5111     }
5112
5113   /* Allocate space for a pointer in the linker section, and allocate a new pointer record
5114      from internal memory.  */
5115   BFD_ASSERT (ptr_linker_section_ptr != NULL);
5116   linker_section_ptr = (elf_linker_section_pointers_t *)
5117     bfd_alloc (abfd, sizeof (elf_linker_section_pointers_t));
5118
5119   if (!linker_section_ptr)
5120     return false;
5121
5122   linker_section_ptr->next = *ptr_linker_section_ptr;
5123   linker_section_ptr->addend = rel->r_addend;
5124   linker_section_ptr->which = lsect->which;
5125   linker_section_ptr->written_address_p = false;
5126   *ptr_linker_section_ptr = linker_section_ptr;
5127
5128 #if 0
5129   if (lsect->hole_size && lsect->hole_offset < lsect->max_hole_offset)
5130     {
5131       linker_section_ptr->offset = lsect->section->_raw_size - lsect->hole_size + (ARCH_SIZE / 8);
5132       lsect->hole_offset += ARCH_SIZE / 8;
5133       lsect->sym_offset  += ARCH_SIZE / 8;
5134       if (lsect->sym_hash)      /* Bump up symbol value if needed */
5135         {
5136           lsect->sym_hash->root.u.def.value += ARCH_SIZE / 8;
5137 #ifdef DEBUG
5138           fprintf (stderr, "Bump up %s by %ld, current value = %ld\n",
5139                    lsect->sym_hash->root.root.string,
5140                    (long)ARCH_SIZE / 8,
5141                    (long)lsect->sym_hash->root.u.def.value);
5142 #endif
5143         }
5144     }
5145   else
5146 #endif
5147     linker_section_ptr->offset = lsect->section->_raw_size;
5148
5149   lsect->section->_raw_size += ARCH_SIZE / 8;
5150
5151 #ifdef DEBUG
5152   fprintf (stderr, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
5153            lsect->name, (long)linker_section_ptr->offset, (long)lsect->section->_raw_size);
5154 #endif
5155
5156   return true;
5157 }
5158
5159 \f
5160 #if ARCH_SIZE==64
5161 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
5162 #endif
5163 #if ARCH_SIZE==32
5164 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
5165 #endif
5166
5167 /* Fill in the address for a pointer generated in alinker section.  */
5168
5169 bfd_vma
5170 elf_finish_pointer_linker_section (output_bfd, input_bfd, info, lsect, h, relocation, rel, relative_reloc)
5171      bfd *output_bfd;
5172      bfd *input_bfd;
5173      struct bfd_link_info *info;
5174      elf_linker_section_t *lsect;
5175      struct elf_link_hash_entry *h;
5176      bfd_vma relocation;
5177      const Elf_Internal_Rela *rel;
5178      int relative_reloc;
5179 {
5180   elf_linker_section_pointers_t *linker_section_ptr;
5181
5182   BFD_ASSERT (lsect != NULL);
5183
5184   if (h != NULL)                /* global symbol */
5185     {
5186       linker_section_ptr = _bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
5187                                                                  rel->r_addend,
5188                                                                  lsect->which);
5189
5190       BFD_ASSERT (linker_section_ptr != NULL);
5191
5192       if (! elf_hash_table (info)->dynamic_sections_created
5193           || (info->shared
5194               && info->symbolic
5195               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5196         {
5197           /* This is actually a static link, or it is a
5198              -Bsymbolic link and the symbol is defined
5199              locally.  We must initialize this entry in the
5200              global section.
5201
5202              When doing a dynamic link, we create a .rela.<xxx>
5203              relocation entry to initialize the value.  This
5204              is done in the finish_dynamic_symbol routine.  */
5205           if (!linker_section_ptr->written_address_p)
5206             {
5207               linker_section_ptr->written_address_p = true;
5208               bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
5209                           lsect->section->contents + linker_section_ptr->offset);
5210             }
5211         }
5212     }
5213   else                          /* local symbol */
5214     {
5215       unsigned long r_symndx = ELF_R_SYM (rel->r_info);
5216       BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
5217       BFD_ASSERT (elf_local_ptr_offsets (input_bfd)[r_symndx] != NULL);
5218       linker_section_ptr = _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd)[r_symndx],
5219                                                                  rel->r_addend,
5220                                                                  lsect->which);
5221
5222       BFD_ASSERT (linker_section_ptr != NULL);
5223
5224       /* Write out pointer if it hasn't been rewritten out before */
5225       if (!linker_section_ptr->written_address_p)
5226         {
5227           linker_section_ptr->written_address_p = true;
5228           bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
5229                        lsect->section->contents + linker_section_ptr->offset);
5230
5231           if (info->shared)
5232             {
5233               asection *srel = lsect->rel_section;
5234               Elf_Internal_Rela outrel;
5235
5236               /* We need to generate a relative reloc for the dynamic linker.  */
5237               if (!srel)
5238                 lsect->rel_section = srel = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
5239                                                                      lsect->rel_name);
5240
5241               BFD_ASSERT (srel != NULL);
5242
5243               outrel.r_offset = (lsect->section->output_section->vma
5244                                  + lsect->section->output_offset
5245                                  + linker_section_ptr->offset);
5246               outrel.r_info = ELF_R_INFO (0, relative_reloc);
5247               outrel.r_addend = 0;
5248               elf_swap_reloca_out (output_bfd, &outrel,
5249                                    (((Elf_External_Rela *)
5250                                      lsect->section->contents)
5251                                     + lsect->section->reloc_count));
5252               ++lsect->section->reloc_count;
5253             }
5254         }
5255     }
5256
5257   relocation = (lsect->section->output_offset
5258                 + linker_section_ptr->offset
5259                 - lsect->hole_offset
5260                 - lsect->sym_offset);
5261
5262 #ifdef DEBUG
5263   fprintf (stderr, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
5264            lsect->name, (long)relocation, (long)relocation);
5265 #endif
5266
5267   /* Subtract out the addend, because it will get added back in by the normal
5268      processing.  */
5269   return relocation - linker_section_ptr->addend;
5270 }