bfd/elflink.h

   1 /* ELF linker support.
   2    Copyright 1995, 1996, 1997, 1998, 1999 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_collect_hash_codes
  52   PARAMS ((struct elf_link_hash_entry *, PTR));
  53 static boolean elf_link_read_relocs_from_section
  54   PARAMS ((bfd *, Elf_Internal_Shdr *, PTR, Elf_Internal_Rela *));
  55 static void elf_link_output_relocs
  56   PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *));
  57 static boolean elf_link_size_reloc_section
  58   PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
  59 static void elf_link_adjust_relocs
  60   PARAMS ((bfd *, Elf_Internal_Shdr *, unsigned int,
  61            struct elf_link_hash_entry **));
  62
  63 /* Given an ELF BFD, add symbols to the global hash table as
  64    appropriate.  */
  65
  66 boolean
  67 elf_bfd_link_add_symbols (abfd, info)
  68      bfd *abfd;
  69      struct bfd_link_info *info;
  70 {
  71   switch (bfd_get_format (abfd))
  72     {
  73     case bfd_object:
  74       return elf_link_add_object_symbols (abfd, info);
  75     case bfd_archive:
  76       return elf_link_add_archive_symbols (abfd, info);
  77     default:
  78       bfd_set_error (bfd_error_wrong_format);
  79       return false;
  80     }
  81 }
  82 \f
  83 /* Search the symbol table of the archive element of the archive ABFD
  84    whoes archove map contains a mention of SYMDEF, and determine if
  85    the symbol is defined in this element.  */
  86 static boolean
  87 elf_link_is_defined_archive_symbol (abfd, symdef)
  88      bfd * abfd;
  89      carsym * symdef;
  90 {
  91   Elf_Internal_Shdr * hdr;
  92   Elf_External_Sym *  esym;
  93   Elf_External_Sym *  esymend;
  94   Elf_External_Sym *  buf = NULL;
  95   size_t symcount;
  96   size_t extsymcount;
  97   size_t extsymoff;
  98   boolean result = false;
  99
 100   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
 101   if (abfd == (bfd *) NULL)
 102     return false;
 103
 104   if (! bfd_check_format (abfd, bfd_object))
 105     return false;
 106
 107   /* Select the appropriate symbol table.  */
 108   if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
 109     hdr = &elf_tdata (abfd)->symtab_hdr;
 110   else
 111     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
 112
 113   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
 114
 115   /* The sh_info field of the symtab header tells us where the
 116      external symbols start.  We don't care about the local symbols.  */
 117   if (elf_bad_symtab (abfd))
 118     {
 119       extsymcount = symcount;
 120       extsymoff = 0;
 121     }
 122   else
 123     {
 124       extsymcount = symcount - hdr->sh_info;
 125       extsymoff = hdr->sh_info;
 126     }
 127
 128   buf = ((Elf_External_Sym *)
 129          bfd_malloc (extsymcount * sizeof (Elf_External_Sym)));
 130   if (buf == NULL && extsymcount != 0)
 131     return false;
 132
 133   /* Read in the symbol table.
 134      FIXME:  This ought to be cached somewhere.  */
 135   if (bfd_seek (abfd,
 136                 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
 137                 SEEK_SET) != 0
 138       || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
 139           != extsymcount * sizeof (Elf_External_Sym)))
 140     {
 141       free (buf);
 142       return false;
 143     }
 144
 145   /* Scan the symbol table looking for SYMDEF.  */
 146   esymend = buf + extsymcount;
 147   for (esym = buf;
 148        esym < esymend;
 149        esym++)
 150     {
 151       Elf_Internal_Sym sym;
 152       const char * name;
 153
 154       elf_swap_symbol_in (abfd, esym, & sym);
 155
 156       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
 157       if (name == (const char *) NULL)
 158         break;
 159
 160       if (strcmp (name, symdef->name) == 0)
 161         {
 162           result =
 163             (ELF_ST_BIND (sym.st_info) == STB_GLOBAL)
 164             && (sym.st_shndx != SHN_UNDEF)
 165             && (sym.st_shndx != SHN_COMMON)
 166             ;
 167           break;
 168         }
 169     }
 170
 171   free (buf);
 172
 173   return result;
 174 }
 175 \f
 176
 177 /* Add symbols from an ELF archive file to the linker hash table.  We
 178    don't use _bfd_generic_link_add_archive_symbols because of a
 179    problem which arises on UnixWare.  The UnixWare libc.so is an
 180    archive which includes an entry libc.so.1 which defines a bunch of
 181    symbols.  The libc.so archive also includes a number of other
 182    object files, which also define symbols, some of which are the same
 183    as those defined in libc.so.1.  Correct linking requires that we
 184    consider each object file in turn, and include it if it defines any
 185    symbols we need.  _bfd_generic_link_add_archive_symbols does not do
 186    this; it looks through the list of undefined symbols, and includes
 187    any object file which defines them.  When this algorithm is used on
 188    UnixWare, it winds up pulling in libc.so.1 early and defining a
 189    bunch of symbols.  This means that some of the other objects in the
 190    archive are not included in the link, which is incorrect since they
 191    precede libc.so.1 in the archive.
 192
 193    Fortunately, ELF archive handling is simpler than that done by
 194    _bfd_generic_link_add_archive_symbols, which has to allow for a.out
 195    oddities.  In ELF, if we find a symbol in the archive map, and the
 196    symbol is currently undefined, we know that we must pull in that
 197    object file.
 198
 199    Unfortunately, we do have to make multiple passes over the symbol
 200    table until nothing further is resolved.  */
 201
 202 static boolean
 203 elf_link_add_archive_symbols (abfd, info)
 204      bfd *abfd;
 205      struct bfd_link_info *info;
 206 {
 207   symindex c;
 208   boolean *defined = NULL;
 209   boolean *included = NULL;
 210   carsym *symdefs;
 211   boolean loop;
 212
 213   if (! bfd_has_map (abfd))
 214     {
 215       /* An empty archive is a special case.  */
 216       if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
 217         return true;
 218       bfd_set_error (bfd_error_no_armap);
 219       return false;
 220     }
 221
 222   /* Keep track of all symbols we know to be already defined, and all
 223      files we know to be already included.  This is to speed up the
 224      second and subsequent passes.  */
 225   c = bfd_ardata (abfd)->symdef_count;
 226   if (c == 0)
 227     return true;
 228   defined = (boolean *) bfd_malloc (c * sizeof (boolean));
 229   included = (boolean *) bfd_malloc (c * sizeof (boolean));
 230   if (defined == (boolean *) NULL || included == (boolean *) NULL)
 231     goto error_return;
 232   memset (defined, 0, c * sizeof (boolean));
 233   memset (included, 0, c * sizeof (boolean));
 234
 235   symdefs = bfd_ardata (abfd)->symdefs;
 236
 237   do
 238     {
 239       file_ptr last;
 240       symindex i;
 241       carsym *symdef;
 242       carsym *symdefend;
 243
 244       loop = false;
 245       last = -1;
 246
 247       symdef = symdefs;
 248       symdefend = symdef + c;
 249       for (i = 0; symdef < symdefend; symdef++, i++)
 250         {
 251           struct elf_link_hash_entry *h;
 252           bfd *element;
 253           struct bfd_link_hash_entry *undefs_tail;
 254           symindex mark;
 255
 256           if (defined[i] || included[i])
 257             continue;
 258           if (symdef->file_offset == last)
 259             {
 260               included[i] = true;
 261               continue;
 262             }
 263
 264           h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
 265                                     false, false, false);
 266
 267           if (h == NULL)
 268             {
 269               char *p, *copy;
 270
 271               /* If this is a default version (the name contains @@),
 272                  look up the symbol again without the version.  The
 273                  effect is that references to the symbol without the
 274                  version will be matched by the default symbol in the
 275                  archive.  */
 276
 277               p = strchr (symdef->name, ELF_VER_CHR);
 278               if (p == NULL || p[1] != ELF_VER_CHR)
 279                 continue;
 280
 281               copy = bfd_alloc (abfd, p - symdef->name + 1);
 282               if (copy == NULL)
 283                 goto error_return;
 284               memcpy (copy, symdef->name, p - symdef->name);
 285               copy[p - symdef->name] = '\0';
 286
 287               h = elf_link_hash_lookup (elf_hash_table (info), copy,
 288                                         false, false, false);
 289
 290               bfd_release (abfd, copy);
 291             }
 292
 293           if (h == NULL)
 294             continue;
 295
 296           if (h->root.type == bfd_link_hash_common)
 297             {
 298               /* We currently have a common symbol.  The archive map contains
 299                  a reference to this symbol, so we may want to include it.  We
 300                  only want to include it however, if this archive element
 301                  contains a definition of the symbol, not just another common
 302                  declaration of it.
 303
 304                  Unfortunately some archivers (including GNU ar) will put
 305                  declarations of common symbols into their archive maps, as
 306                  well as real definitions, so we cannot just go by the archive
 307                  map alone.  Instead we must read in the element's symbol
 308                  table and check that to see what kind of symbol definition
 309                  this is.  */
 310               if (! elf_link_is_defined_archive_symbol (abfd, symdef))
 311                 continue;
 312             }
 313           else if (h->root.type != bfd_link_hash_undefined)
 314             {
 315               if (h->root.type != bfd_link_hash_undefweak)
 316                 defined[i] = true;
 317               continue;
 318             }
 319
 320           /* We need to include this archive member.  */
 321
 322           element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
 323           if (element == (bfd *) NULL)
 324             goto error_return;
 325
 326           if (! bfd_check_format (element, bfd_object))
 327             goto error_return;
 328
 329           /* Doublecheck that we have not included this object
 330              already--it should be impossible, but there may be
 331              something wrong with the archive.  */
 332           if (element->archive_pass != 0)
 333             {
 334               bfd_set_error (bfd_error_bad_value);
 335               goto error_return;
 336             }
 337           element->archive_pass = 1;
 338
 339           undefs_tail = info->hash->undefs_tail;
 340
 341           if (! (*info->callbacks->add_archive_element) (info, element,
 342                                                          symdef->name))
 343             goto error_return;
 344           if (! elf_link_add_object_symbols (element, info))
 345             goto error_return;
 346
 347           /* If there are any new undefined symbols, we need to make
 348              another pass through the archive in order to see whether
 349              they can be defined.  FIXME: This isn't perfect, because
 350              common symbols wind up on undefs_tail and because an
 351              undefined symbol which is defined later on in this pass
 352              does not require another pass.  This isn't a bug, but it
 353              does make the code less efficient than it could be.  */
 354           if (undefs_tail != info->hash->undefs_tail)
 355             loop = true;
 356
 357           /* Look backward to mark all symbols from this object file
 358              which we have already seen in this pass.  */
 359           mark = i;
 360           do
 361             {
 362               included[mark] = true;
 363               if (mark == 0)
 364                 break;
 365               --mark;
 366             }
 367           while (symdefs[mark].file_offset == symdef->file_offset);
 368
 369           /* We mark subsequent symbols from this object file as we go
 370              on through the loop.  */
 371           last = symdef->file_offset;
 372         }
 373     }
 374   while (loop);
 375
 376   free (defined);
 377   free (included);
 378
 379   return true;
 380
 381  error_return:
 382   if (defined != (boolean *) NULL)
 383     free (defined);
 384   if (included != (boolean *) NULL)
 385     free (included);
 386   return false;
 387 }
 388
 389 /* This function is called when we want to define a new symbol.  It
 390    handles the various cases which arise when we find a definition in
 391    a dynamic object, or when there is already a definition in a
 392    dynamic object.  The new symbol is described by NAME, SYM, PSEC,
 393    and PVALUE.  We set SYM_HASH to the hash table entry.  We set
 394    OVERRIDE if the old symbol is overriding a new definition.  We set
 395    TYPE_CHANGE_OK if it is OK for the type to change.  We set
 396    SIZE_CHANGE_OK if it is OK for the size to change.  By OK to
 397    change, we mean that we shouldn't warn if the type or size does
 398    change.  */
 399
 400 static boolean
 401 elf_merge_symbol (abfd, info, name, sym, psec, pvalue, sym_hash,
 402                   override, type_change_ok, size_change_ok)
 403      bfd *abfd;
 404      struct bfd_link_info *info;
 405      const char *name;
 406      Elf_Internal_Sym *sym;
 407      asection **psec;
 408      bfd_vma *pvalue;
 409      struct elf_link_hash_entry **sym_hash;
 410      boolean *override;
 411      boolean *type_change_ok;
 412      boolean *size_change_ok;
 413 {
 414   asection *sec;
 415   struct elf_link_hash_entry *h;
 416   int bind;
 417   bfd *oldbfd;
 418   boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
 419
 420   *override = false;
 421
 422   sec = *psec;
 423   bind = ELF_ST_BIND (sym->st_info);
 424
 425   if (! bfd_is_und_section (sec))
 426     h = elf_link_hash_lookup (elf_hash_table (info), name, true, false, false);
 427   else
 428     h = ((struct elf_link_hash_entry *)
 429          bfd_wrapped_link_hash_lookup (abfd, info, name, true, false, false));
 430   if (h == NULL)
 431     return false;
 432   *sym_hash = h;
 433
 434   /* This code is for coping with dynamic objects, and is only useful
 435      if we are doing an ELF link.  */
 436   if (info->hash->creator != abfd->xvec)
 437     return true;
 438
 439   /* For merging, we only care about real symbols.  */
 440
 441   while (h->root.type == bfd_link_hash_indirect
 442          || h->root.type == bfd_link_hash_warning)
 443     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 444
 445   /* If we just created the symbol, mark it as being an ELF symbol.
 446      Other than that, there is nothing to do--there is no merge issue
 447      with a newly defined symbol--so we just return.  */
 448
 449   if (h->root.type == bfd_link_hash_new)
 450     {
 451       h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
 452       return true;
 453     }
 454
 455   /* OLDBFD is a BFD associated with the existing symbol.  */
 456
 457   switch (h->root.type)
 458     {
 459     default:
 460       oldbfd = NULL;
 461       break;
 462
 463     case bfd_link_hash_undefined:
 464     case bfd_link_hash_undefweak:
 465       oldbfd = h->root.u.undef.abfd;
 466       break;
 467
 468     case bfd_link_hash_defined:
 469     case bfd_link_hash_defweak:
 470       oldbfd = h->root.u.def.section->owner;
 471       break;
 472
 473     case bfd_link_hash_common:
 474       oldbfd = h->root.u.c.p->section->owner;
 475       break;
 476     }
 477
 478   /* In cases involving weak versioned symbols, we may wind up trying
 479      to merge a symbol with itself.  Catch that here, to avoid the
 480      confusion that results if we try to override a symbol with
 481      itself.  The additional tests catch cases like
 482      _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
 483      dynamic object, which we do want to handle here.  */
 484   if (abfd == oldbfd
 485       && ((abfd->flags & DYNAMIC) == 0
 486           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0))
 487     return true;
 488
 489   /* NEWDYN and OLDDYN indicate whether the new or old symbol,
 490      respectively, is from a dynamic object.  */
 491
 492   if ((abfd->flags & DYNAMIC) != 0)
 493     newdyn = true;
 494   else
 495     newdyn = false;
 496
 497   if (oldbfd != NULL)
 498     olddyn = (oldbfd->flags & DYNAMIC) != 0;
 499   else
 500     {
 501       asection *hsec;
 502
 503       /* This code handles the special SHN_MIPS_{TEXT,DATA} section
 504          indices used by MIPS ELF.  */
 505       switch (h->root.type)
 506         {
 507         default:
 508           hsec = NULL;
 509           break;
 510
 511         case bfd_link_hash_defined:
 512         case bfd_link_hash_defweak:
 513           hsec = h->root.u.def.section;
 514           break;
 515
 516         case bfd_link_hash_common:
 517           hsec = h->root.u.c.p->section;
 518           break;
 519         }
 520
 521       if (hsec == NULL)
 522         olddyn = false;
 523       else
 524         olddyn = (hsec->symbol->flags & BSF_DYNAMIC) != 0;
 525     }
 526
 527   /* NEWDEF and OLDDEF indicate whether the new or old symbol,
 528      respectively, appear to be a definition rather than reference.  */
 529
 530   if (bfd_is_und_section (sec) || bfd_is_com_section (sec))
 531     newdef = false;
 532   else
 533     newdef = true;
 534
 535   if (h->root.type == bfd_link_hash_undefined
 536       || h->root.type == bfd_link_hash_undefweak
 537       || h->root.type == bfd_link_hash_common)
 538     olddef = false;
 539   else
 540     olddef = true;
 541
 542   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
 543      symbol, respectively, appears to be a common symbol in a dynamic
 544      object.  If a symbol appears in an uninitialized section, and is
 545      not weak, and is not a function, then it may be a common symbol
 546      which was resolved when the dynamic object was created.  We want
 547      to treat such symbols specially, because they raise special
 548      considerations when setting the symbol size: if the symbol
 549      appears as a common symbol in a regular object, and the size in
 550      the regular object is larger, we must make sure that we use the
 551      larger size.  This problematic case can always be avoided in C,
 552      but it must be handled correctly when using Fortran shared
 553      libraries.
 554
 555      Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
 556      likewise for OLDDYNCOMMON and OLDDEF.
 557
 558      Note that this test is just a heuristic, and that it is quite
 559      possible to have an uninitialized symbol in a shared object which
 560      is really a definition, rather than a common symbol.  This could
 561      lead to some minor confusion when the symbol really is a common
 562      symbol in some regular object.  However, I think it will be
 563      harmless.  */
 564
 565   if (newdyn
 566       && newdef
 567       && (sec->flags & SEC_ALLOC) != 0
 568       && (sec->flags & SEC_LOAD) == 0
 569       && sym->st_size > 0
 570       && bind != STB_WEAK
 571       && ELF_ST_TYPE (sym->st_info) != STT_FUNC)
 572     newdyncommon = true;
 573   else
 574     newdyncommon = false;
 575
 576   if (olddyn
 577       && olddef
 578       && h->root.type == bfd_link_hash_defined
 579       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 580       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
 581       && (h->root.u.def.section->flags & SEC_LOAD) == 0
 582       && h->size > 0
 583       && h->type != STT_FUNC)
 584     olddyncommon = true;
 585   else
 586     olddyncommon = false;
 587
 588   /* It's OK to change the type if either the existing symbol or the
 589      new symbol is weak.  */
 590
 591   if (h->root.type == bfd_link_hash_defweak
 592       || h->root.type == bfd_link_hash_undefweak
 593       || bind == STB_WEAK)
 594     *type_change_ok = true;
 595
 596   /* It's OK to change the size if either the existing symbol or the
 597      new symbol is weak, or if the old symbol is undefined.  */
 598
 599   if (*type_change_ok
 600       || h->root.type == bfd_link_hash_undefined)
 601     *size_change_ok = true;
 602
 603   /* If both the old and the new symbols look like common symbols in a
 604      dynamic object, set the size of the symbol to the larger of the
 605      two.  */
 606
 607   if (olddyncommon
 608       && newdyncommon
 609       && sym->st_size != h->size)
 610     {
 611       /* Since we think we have two common symbols, issue a multiple
 612          common warning if desired.  Note that we only warn if the
 613          size is different.  If the size is the same, we simply let
 614          the old symbol override the new one as normally happens with
 615          symbols defined in dynamic objects.  */
 616
 617       if (! ((*info->callbacks->multiple_common)
 618              (info, h->root.root.string, oldbfd, bfd_link_hash_common,
 619               h->size, abfd, bfd_link_hash_common, sym->st_size)))
 620         return false;
 621
 622       if (sym->st_size > h->size)
 623         h->size = sym->st_size;
 624
 625       *size_change_ok = true;
 626     }
 627
 628   /* If we are looking at a dynamic object, and we have found a
 629      definition, we need to see if the symbol was already defined by
 630      some other object.  If so, we want to use the existing
 631      definition, and we do not want to report a multiple symbol
 632      definition error; we do this by clobbering *PSEC to be
 633      bfd_und_section_ptr.
 634
 635      We treat a common symbol as a definition if the symbol in the
 636      shared library is a function, since common symbols always
 637      represent variables; this can cause confusion in principle, but
 638      any such confusion would seem to indicate an erroneous program or
 639      shared library.  We also permit a common symbol in a regular
 640      object to override a weak symbol in a shared object.
 641
 642      We prefer a non-weak definition in a shared library to a weak
 643      definition in the executable.  */
 644
 645   if (newdyn
 646       && newdef
 647       && (olddef
 648           || (h->root.type == bfd_link_hash_common
 649               && (bind == STB_WEAK
 650                   || ELF_ST_TYPE (sym->st_info) == STT_FUNC)))
 651       && (h->root.type != bfd_link_hash_defweak
 652           || bind == STB_WEAK))
 653     {
 654       *override = true;
 655       newdef = false;
 656       newdyncommon = false;
 657
 658       *psec = sec = bfd_und_section_ptr;
 659       *size_change_ok = true;
 660
 661       /* If we get here when the old symbol is a common symbol, then
 662          we are explicitly letting it override a weak symbol or
 663          function in a dynamic object, and we don't want to warn about
 664          a type change.  If the old symbol is a defined symbol, a type
 665          change warning may still be appropriate.  */
 666
 667       if (h->root.type == bfd_link_hash_common)
 668         *type_change_ok = true;
 669     }
 670
 671   /* Handle the special case of an old common symbol merging with a
 672      new symbol which looks like a common symbol in a shared object.
 673      We change *PSEC and *PVALUE to make the new symbol look like a
 674      common symbol, and let _bfd_generic_link_add_one_symbol will do
 675      the right thing.  */
 676
 677   if (newdyncommon
 678       && h->root.type == bfd_link_hash_common)
 679     {
 680       *override = true;
 681       newdef = false;
 682       newdyncommon = false;
 683       *pvalue = sym->st_size;
 684       *psec = sec = bfd_com_section_ptr;
 685       *size_change_ok = true;
 686     }
 687
 688   /* If the old symbol is from a dynamic object, and the new symbol is
 689      a definition which is not from a dynamic object, then the new
 690      symbol overrides the old symbol.  Symbols from regular files
 691      always take precedence over symbols from dynamic objects, even if
 692      they are defined after the dynamic object in the link.
 693
 694      As above, we again permit a common symbol in a regular object to
 695      override a definition in a shared object if the shared object
 696      symbol is a function or is weak.
 697
 698      As above, we permit a non-weak definition in a shared object to
 699      override a weak definition in a regular object.  */
 700
 701   if (! newdyn
 702       && (newdef
 703           || (bfd_is_com_section (sec)
 704               && (h->root.type == bfd_link_hash_defweak
 705                   || h->type == STT_FUNC)))
 706       && olddyn
 707       && olddef
 708       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 709       && (bind != STB_WEAK
 710           || h->root.type == bfd_link_hash_defweak))
 711     {
 712       /* Change the hash table entry to undefined, and let
 713          _bfd_generic_link_add_one_symbol do the right thing with the
 714          new definition.  */
 715
 716       h->root.type = bfd_link_hash_undefined;
 717       h->root.u.undef.abfd = h->root.u.def.section->owner;
 718       *size_change_ok = true;
 719
 720       olddef = false;
 721       olddyncommon = false;
 722
 723       /* We again permit a type change when a common symbol may be
 724          overriding a function.  */
 725
 726       if (bfd_is_com_section (sec))
 727         *type_change_ok = true;
 728
 729       /* This union may have been set to be non-NULL when this symbol
 730          was seen in a dynamic object.  We must force the union to be
 731          NULL, so that it is correct for a regular symbol.  */
 732
 733       h->verinfo.vertree = NULL;
 734
 735       /* In this special case, if H is the target of an indirection,
 736          we want the caller to frob with H rather than with the
 737          indirect symbol.  That will permit the caller to redefine the
 738          target of the indirection, rather than the indirect symbol
 739          itself.  FIXME: This will break the -y option if we store a
 740          symbol with a different name.  */
 741       *sym_hash = h;
 742     }
 743
 744   /* Handle the special case of a new common symbol merging with an
 745      old symbol that looks like it might be a common symbol defined in
 746      a shared object.  Note that we have already handled the case in
 747      which a new common symbol should simply override the definition
 748      in the shared library.  */
 749
 750   if (! newdyn
 751       && bfd_is_com_section (sec)
 752       && olddyncommon)
 753     {
 754       /* It would be best if we could set the hash table entry to a
 755          common symbol, but we don't know what to use for the section
 756          or the alignment.  */
 757       if (! ((*info->callbacks->multiple_common)
 758              (info, h->root.root.string, oldbfd, bfd_link_hash_common,
 759               h->size, abfd, bfd_link_hash_common, sym->st_size)))
 760         return false;
 761
 762       /* If the predumed common symbol in the dynamic object is
 763          larger, pretend that the new symbol has its size.  */
 764
 765       if (h->size > *pvalue)
 766         *pvalue = h->size;
 767
 768       /* FIXME: We no longer know the alignment required by the symbol
 769          in the dynamic object, so we just wind up using the one from
 770          the regular object.  */
 771
 772       olddef = false;
 773       olddyncommon = false;
 774
 775       h->root.type = bfd_link_hash_undefined;
 776       h->root.u.undef.abfd = h->root.u.def.section->owner;
 777
 778       *size_change_ok = true;
 779       *type_change_ok = true;
 780
 781       h->verinfo.vertree = NULL;
 782     }
 783
 784   /* Handle the special case of a weak definition in a regular object
 785      followed by a non-weak definition in a shared object.  In this
 786      case, we prefer the definition in the shared object.  */
 787   if (olddef
 788       && h->root.type == bfd_link_hash_defweak
 789       && newdef
 790       && newdyn
 791       && bind != STB_WEAK)
 792     {
 793       /* To make this work we have to frob the flags so that the rest
 794          of the code does not think we are using the regular
 795          definition.  */
 796       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
 797         h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
 798       else if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
 799         h->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
 800       h->elf_link_hash_flags &= ~ (ELF_LINK_HASH_DEF_REGULAR
 801                                    | ELF_LINK_HASH_DEF_DYNAMIC);
 802
 803       /* If H is the target of an indirection, we want the caller to
 804          use H rather than the indirect symbol.  Otherwise if we are
 805          defining a new indirect symbol we will wind up attaching it
 806          to the entry we are overriding.  */
 807       *sym_hash = h;
 808     }
 809
 810   /* Handle the special case of a non-weak definition in a shared
 811      object followed by a weak definition in a regular object.  In
 812      this case we prefer to definition in the shared object.  To make
 813      this work we have to tell the caller to not treat the new symbol
 814      as a definition.  */
 815   if (olddef
 816       && olddyn
 817       && h->root.type != bfd_link_hash_defweak
 818       && newdef
 819       && ! newdyn
 820       && bind == STB_WEAK)
 821     *override = true;
 822
 823   return true;
 824 }
 825
 826 /* Add symbols from an ELF object file to the linker hash table.  */
 827
 828 static boolean
 829 elf_link_add_object_symbols (abfd, info)
 830      bfd *abfd;
 831      struct bfd_link_info *info;
 832 {
 833   boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
 834                                       const Elf_Internal_Sym *,
 835                                       const char **, flagword *,
 836                                       asection **, bfd_vma *));
 837   boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
 838                                    asection *, const Elf_Internal_Rela *));
 839   boolean collect;
 840   Elf_Internal_Shdr *hdr;
 841   size_t symcount;
 842   size_t extsymcount;
 843   size_t extsymoff;
 844   Elf_External_Sym *buf = NULL;
 845   struct elf_link_hash_entry **sym_hash;
 846   boolean dynamic;
 847   bfd_byte *dynver = NULL;
 848   Elf_External_Versym *extversym = NULL;
 849   Elf_External_Versym *ever;
 850   Elf_External_Dyn *dynbuf = NULL;
 851   struct elf_link_hash_entry *weaks;
 852   Elf_External_Sym *esym;
 853   Elf_External_Sym *esymend;
 854
 855   add_symbol_hook = get_elf_backend_data (abfd)->elf_add_symbol_hook;
 856   collect = get_elf_backend_data (abfd)->collect;
 857
 858   if ((abfd->flags & DYNAMIC) == 0)
 859     dynamic = false;
 860   else
 861     {
 862       dynamic = true;
 863
 864       /* You can't use -r against a dynamic object.  Also, there's no
 865          hope of using a dynamic object which does not exactly match
 866          the format of the output file.  */
 867       if (info->relocateable || info->hash->creator != abfd->xvec)
 868         {
 869           bfd_set_error (bfd_error_invalid_operation);
 870           goto error_return;
 871         }
 872     }
 873
 874   /* As a GNU extension, any input sections which are named
 875      .gnu.warning.SYMBOL are treated as warning symbols for the given
 876      symbol.  This differs from .gnu.warning sections, which generate
 877      warnings when they are included in an output file.  */
 878   if (! info->shared)
 879     {
 880       asection *s;
 881
 882       for (s = abfd->sections; s != NULL; s = s->next)
 883         {
 884           const char *name;
 885
 886           name = bfd_get_section_name (abfd, s);
 887           if (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
 888             {
 889               char *msg;
 890               bfd_size_type sz;
 891
 892               name += sizeof ".gnu.warning." - 1;
 893
 894               /* If this is a shared object, then look up the symbol
 895                  in the hash table.  If it is there, and it is already
 896                  been defined, then we will not be using the entry
 897                  from this shared object, so we don't need to warn.
 898                  FIXME: If we see the definition in a regular object
 899                  later on, we will warn, but we shouldn't.  The only
 900                  fix is to keep track of what warnings we are supposed
 901                  to emit, and then handle them all at the end of the
 902                  link.  */
 903               if (dynamic && abfd->xvec == info->hash->creator)
 904                 {
 905                   struct elf_link_hash_entry *h;
 906
 907                   h = elf_link_hash_lookup (elf_hash_table (info), name,
 908                                             false, false, true);
 909
 910                   /* FIXME: What about bfd_link_hash_common?  */
 911                   if (h != NULL
 912                       && (h->root.type == bfd_link_hash_defined
 913                           || h->root.type == bfd_link_hash_defweak))
 914                     {
 915                       /* We don't want to issue this warning.  Clobber
 916                          the section size so that the warning does not
 917                          get copied into the output file.  */
 918                       s->_raw_size = 0;
 919                       continue;
 920                     }
 921                 }
 922
 923               sz = bfd_section_size (abfd, s);
 924               msg = (char *) bfd_alloc (abfd, sz + 1);
 925               if (msg == NULL)
 926                 goto error_return;
 927
 928               if (! bfd_get_section_contents (abfd, s, msg, (file_ptr) 0, sz))
 929                 goto error_return;
 930
 931               msg[sz] = '\0';
 932
 933               if (! (_bfd_generic_link_add_one_symbol
 934                      (info, abfd, name, BSF_WARNING, s, (bfd_vma) 0, msg,
 935                       false, collect, (struct bfd_link_hash_entry **) NULL)))
 936                 goto error_return;
 937
 938               if (! info->relocateable)
 939                 {
 940                   /* Clobber the section size so that the warning does
 941                      not get copied into the output file.  */
 942                   s->_raw_size = 0;
 943                 }
 944             }
 945         }
 946     }
 947
 948   /* If this is a dynamic object, we always link against the .dynsym
 949      symbol table, not the .symtab symbol table.  The dynamic linker
 950      will only see the .dynsym symbol table, so there is no reason to
 951      look at .symtab for a dynamic object.  */
 952
 953   if (! dynamic || elf_dynsymtab (abfd) == 0)
 954     hdr = &elf_tdata (abfd)->symtab_hdr;
 955   else
 956     hdr = &elf_tdata (abfd)->dynsymtab_hdr;
 957
 958   if (dynamic)
 959     {
 960       /* Read in any version definitions.  */
 961
 962       if (! _bfd_elf_slurp_version_tables (abfd))
 963         goto error_return;
 964
 965       /* Read in the symbol versions, but don't bother to convert them
 966          to internal format.  */
 967       if (elf_dynversym (abfd) != 0)
 968         {
 969           Elf_Internal_Shdr *versymhdr;
 970
 971           versymhdr = &elf_tdata (abfd)->dynversym_hdr;
 972           extversym = (Elf_External_Versym *) bfd_malloc (hdr->sh_size);
 973           if (extversym == NULL)
 974             goto error_return;
 975           if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
 976               || (bfd_read ((PTR) extversym, 1, versymhdr->sh_size, abfd)
 977                   != versymhdr->sh_size))
 978             goto error_return;
 979         }
 980     }
 981
 982   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
 983
 984   /* The sh_info field of the symtab header tells us where the
 985      external symbols start.  We don't care about the local symbols at
 986      this point.  */
 987   if (elf_bad_symtab (abfd))
 988     {
 989       extsymcount = symcount;
 990       extsymoff = 0;
 991     }
 992   else
 993     {
 994       extsymcount = symcount - hdr->sh_info;
 995       extsymoff = hdr->sh_info;
 996     }
 997
 998   buf = ((Elf_External_Sym *)
 999          bfd_malloc (extsymcount * sizeof (Elf_External_Sym)));
1000   if (buf == NULL && extsymcount != 0)
1001     goto error_return;
1002
1003   /* We store a pointer to the hash table entry for each external
1004      symbol.  */
1005   sym_hash = ((struct elf_link_hash_entry **)
1006               bfd_alloc (abfd,
1007                          extsymcount * sizeof (struct elf_link_hash_entry *)));
1008   if (sym_hash == NULL)
1009     goto error_return;
1010   elf_sym_hashes (abfd) = sym_hash;
1011
1012   if (! dynamic)
1013     {
1014       /* If we are creating a shared library, create all the dynamic
1015          sections immediately.  We need to attach them to something,
1016          so we attach them to this BFD, provided it is the right
1017          format.  FIXME: If there are no input BFD's of the same
1018          format as the output, we can't make a shared library.  */
1019       if (info->shared
1020           && ! elf_hash_table (info)->dynamic_sections_created
1021           && abfd->xvec == info->hash->creator)
1022         {
1023           if (! elf_link_create_dynamic_sections (abfd, info))
1024             goto error_return;
1025         }
1026     }
1027   else
1028     {
1029       asection *s;
1030       boolean add_needed;
1031       const char *name;
1032       bfd_size_type oldsize;
1033       bfd_size_type strindex;
1034
1035       /* Find the name to use in a DT_NEEDED entry that refers to this
1036          object.  If the object has a DT_SONAME entry, we use it.
1037          Otherwise, if the generic linker stuck something in
1038          elf_dt_name, we use that.  Otherwise, we just use the file
1039          name.  If the generic linker put a null string into
1040          elf_dt_name, we don't make a DT_NEEDED entry at all, even if
1041          there is a DT_SONAME entry.  */
1042       add_needed = true;
1043       name = bfd_get_filename (abfd);
1044       if (elf_dt_name (abfd) != NULL)
1045         {
1046           name = elf_dt_name (abfd);
1047           if (*name == '\0')
1048             add_needed = false;
1049         }
1050       s = bfd_get_section_by_name (abfd, ".dynamic");
1051       if (s != NULL)
1052         {
1053           Elf_External_Dyn *extdyn;
1054           Elf_External_Dyn *extdynend;
1055           int elfsec;
1056           unsigned long link;
1057
1058           dynbuf = (Elf_External_Dyn *) bfd_malloc ((size_t) s->_raw_size);
1059           if (dynbuf == NULL)
1060             goto error_return;
1061
1062           if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
1063                                           (file_ptr) 0, s->_raw_size))
1064             goto error_return;
1065
1066           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1067           if (elfsec == -1)
1068             goto error_return;
1069           link = elf_elfsections (abfd)[elfsec]->sh_link;
1070
1071           {
1072             /* The shared libraries distributed with hpux11 have a bogus
1073                sh_link field for the ".dynamic" section.  This code detects
1074                when LINK refers to a section that is not a string table and
1075                tries to find the string table for the ".dynsym" section
1076                instead.  */
1077             Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[link];
1078             if (hdr->sh_type != SHT_STRTAB)
1079               {
1080                 asection *s = bfd_get_section_by_name (abfd, ".dynsym");
1081                 int elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1082                 if (elfsec == -1)
1083                   goto error_return;
1084                 link = elf_elfsections (abfd)[elfsec]->sh_link;
1085               }
1086           }
1087
1088           extdyn = dynbuf;
1089           extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
1090           for (; extdyn < extdynend; extdyn++)
1091             {
1092               Elf_Internal_Dyn dyn;
1093
1094               elf_swap_dyn_in (abfd, extdyn, &dyn);
1095               if (dyn.d_tag == DT_SONAME)
1096                 {
1097                   name = bfd_elf_string_from_elf_section (abfd, link,
1098                                                           dyn.d_un.d_val);
1099                   if (name == NULL)
1100                     goto error_return;
1101                 }
1102               if (dyn.d_tag == DT_NEEDED)
1103                 {
1104                   struct bfd_link_needed_list *n, **pn;
1105                   char *fnm, *anm;
1106
1107                   n = ((struct bfd_link_needed_list *)
1108                        bfd_alloc (abfd, sizeof (struct bfd_link_needed_list)));
1109                   fnm = bfd_elf_string_from_elf_section (abfd, link,
1110                                                          dyn.d_un.d_val);
1111                   if (n == NULL || fnm == NULL)
1112                     goto error_return;
1113                   anm = bfd_alloc (abfd, strlen (fnm) + 1);
1114                   if (anm == NULL)
1115                     goto error_return;
1116                   strcpy (anm, fnm);
1117                   n->name = anm;
1118                   n->by = abfd;
1119                   n->next = NULL;
1120                   for (pn = &elf_hash_table (info)->needed;
1121                        *pn != NULL;
1122                        pn = &(*pn)->next)
1123                     ;
1124                   *pn = n;
1125                 }
1126             }
1127
1128           free (dynbuf);
1129           dynbuf = NULL;
1130         }
1131
1132       /* We do not want to include any of the sections in a dynamic
1133          object in the output file.  We hack by simply clobbering the
1134          list of sections in the BFD.  This could be handled more
1135          cleanly by, say, a new section flag; the existing
1136          SEC_NEVER_LOAD flag is not the one we want, because that one
1137          still implies that the section takes up space in the output
1138          file.  */
1139       abfd->sections = NULL;
1140       abfd->section_count = 0;
1141
1142       /* If this is the first dynamic object found in the link, create
1143          the special sections required for dynamic linking.  */
1144       if (! elf_hash_table (info)->dynamic_sections_created)
1145         {
1146           if (! elf_link_create_dynamic_sections (abfd, info))
1147             goto error_return;
1148         }
1149
1150       if (add_needed)
1151         {
1152           /* Add a DT_NEEDED entry for this dynamic object.  */
1153           oldsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1154           strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr, name,
1155                                          true, false);
1156           if (strindex == (bfd_size_type) -1)
1157             goto error_return;
1158
1159           if (oldsize == _bfd_stringtab_size (elf_hash_table (info)->dynstr))
1160             {
1161               asection *sdyn;
1162               Elf_External_Dyn *dyncon, *dynconend;
1163
1164               /* The hash table size did not change, which means that
1165                  the dynamic object name was already entered.  If we
1166                  have already included this dynamic object in the
1167                  link, just ignore it.  There is no reason to include
1168                  a particular dynamic object more than once.  */
1169               sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
1170                                               ".dynamic");
1171               BFD_ASSERT (sdyn != NULL);
1172
1173               dyncon = (Elf_External_Dyn *) sdyn->contents;
1174               dynconend = (Elf_External_Dyn *) (sdyn->contents +
1175                                                 sdyn->_raw_size);
1176               for (; dyncon < dynconend; dyncon++)
1177                 {
1178                   Elf_Internal_Dyn dyn;
1179
1180                   elf_swap_dyn_in (elf_hash_table (info)->dynobj, dyncon,
1181                                    &dyn);
1182                   if (dyn.d_tag == DT_NEEDED
1183                       && dyn.d_un.d_val == strindex)
1184                     {
1185                       if (buf != NULL)
1186                         free (buf);
1187                       if (extversym != NULL)
1188                         free (extversym);
1189                       return true;
1190                     }
1191                 }
1192             }
1193
1194           if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
1195             goto error_return;
1196         }
1197
1198       /* Save the SONAME, if there is one, because sometimes the
1199          linker emulation code will need to know it.  */
1200       if (*name == '\0')
1201         name = bfd_get_filename (abfd);
1202       elf_dt_name (abfd) = name;
1203     }
1204
1205   if (bfd_seek (abfd,
1206                 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
1207                 SEEK_SET) != 0
1208       || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
1209           != extsymcount * sizeof (Elf_External_Sym)))
1210     goto error_return;
1211
1212   weaks = NULL;
1213
1214   ever = extversym != NULL ? extversym + extsymoff : NULL;
1215   esymend = buf + extsymcount;
1216   for (esym = buf;
1217        esym < esymend;
1218        esym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
1219     {
1220       Elf_Internal_Sym sym;
1221       int bind;
1222       bfd_vma value;
1223       asection *sec;
1224       flagword flags;
1225       const char *name;
1226       struct elf_link_hash_entry *h;
1227       boolean definition;
1228       boolean size_change_ok, type_change_ok;
1229       boolean new_weakdef;
1230       unsigned int old_alignment;
1231
1232       elf_swap_symbol_in (abfd, esym, &sym);
1233
1234       flags = BSF_NO_FLAGS;
1235       sec = NULL;
1236       value = sym.st_value;
1237       *sym_hash = NULL;
1238
1239       bind = ELF_ST_BIND (sym.st_info);
1240       if (bind == STB_LOCAL)
1241         {
1242           /* This should be impossible, since ELF requires that all
1243              global symbols follow all local symbols, and that sh_info
1244              point to the first global symbol.  Unfortunatealy, Irix 5
1245              screws this up.  */
1246           continue;
1247         }
1248       else if (bind == STB_GLOBAL)
1249         {
1250           if (sym.st_shndx != SHN_UNDEF
1251               && sym.st_shndx != SHN_COMMON)
1252             flags = BSF_GLOBAL;
1253           else
1254             flags = 0;
1255         }
1256       else if (bind == STB_WEAK)
1257         flags = BSF_WEAK;
1258       else
1259         {
1260           /* Leave it up to the processor backend.  */
1261         }
1262
1263       if (sym.st_shndx == SHN_UNDEF)
1264         sec = bfd_und_section_ptr;
1265       else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
1266         {
1267           sec = section_from_elf_index (abfd, sym.st_shndx);
1268           if (sec == NULL)
1269             sec = bfd_abs_section_ptr;
1270           else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1271             value -= sec->vma;
1272         }
1273       else if (sym.st_shndx == SHN_ABS)
1274         sec = bfd_abs_section_ptr;
1275       else if (sym.st_shndx == SHN_COMMON)
1276         {
1277           sec = bfd_com_section_ptr;
1278           /* What ELF calls the size we call the value.  What ELF
1279              calls the value we call the alignment.  */
1280           value = sym.st_size;
1281         }
1282       else
1283         {
1284           /* Leave it up to the processor backend.  */
1285         }
1286
1287       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
1288       if (name == (const char *) NULL)
1289         goto error_return;
1290
1291       if (add_symbol_hook)
1292         {
1293           if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
1294                                     &value))
1295             goto error_return;
1296
1297           /* The hook function sets the name to NULL if this symbol
1298              should be skipped for some reason.  */
1299           if (name == (const char *) NULL)
1300             continue;
1301         }
1302
1303       /* Sanity check that all possibilities were handled.  */
1304       if (sec == (asection *) NULL)
1305         {
1306           bfd_set_error (bfd_error_bad_value);
1307           goto error_return;
1308         }
1309
1310       if (bfd_is_und_section (sec)
1311           || bfd_is_com_section (sec))
1312         definition = false;
1313       else
1314         definition = true;
1315
1316       size_change_ok = false;
1317       type_change_ok = get_elf_backend_data (abfd)->type_change_ok;
1318       old_alignment = 0;
1319       if (info->hash->creator->flavour == bfd_target_elf_flavour)
1320         {
1321           Elf_Internal_Versym iver;
1322           unsigned int vernum = 0;
1323           boolean override;
1324
1325           if (ever != NULL)
1326             {
1327               _bfd_elf_swap_versym_in (abfd, ever, &iver);
1328               vernum = iver.vs_vers & VERSYM_VERSION;
1329
1330               /* If this is a hidden symbol, or if it is not version
1331                  1, we append the version name to the symbol name.
1332                  However, we do not modify a non-hidden absolute
1333                  symbol, because it might be the version symbol
1334                  itself.  FIXME: What if it isn't?  */
1335               if ((iver.vs_vers & VERSYM_HIDDEN) != 0
1336                   || (vernum > 1 && ! bfd_is_abs_section (sec)))
1337                 {
1338                   const char *verstr;
1339                   int namelen, newlen;
1340                   char *newname, *p;
1341
1342                   if (sym.st_shndx != SHN_UNDEF)
1343                     {
1344                       if (vernum > elf_tdata (abfd)->dynverdef_hdr.sh_info)
1345                         {
1346                           (*_bfd_error_handler)
1347                             (_("%s: %s: invalid version %u (max %d)"),
1348                              bfd_get_filename (abfd), name, vernum,
1349                              elf_tdata (abfd)->dynverdef_hdr.sh_info);
1350                           bfd_set_error (bfd_error_bad_value);
1351                           goto error_return;
1352                         }
1353                       else if (vernum > 1)
1354                         verstr =
1355                           elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1356                       else
1357                         verstr = "";
1358                     }
1359                   else
1360                     {
1361                       /* We cannot simply test for the number of
1362                          entries in the VERNEED section since the
1363                          numbers for the needed versions do not start
1364                          at 0.  */
1365                       Elf_Internal_Verneed *t;
1366
1367                       verstr = NULL;
1368                       for (t = elf_tdata (abfd)->verref;
1369                            t != NULL;
1370                            t = t->vn_nextref)
1371                         {
1372                           Elf_Internal_Vernaux *a;
1373
1374                           for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1375                             {
1376                               if (a->vna_other == vernum)
1377                                 {
1378                                   verstr = a->vna_nodename;
1379                                   break;
1380                                 }
1381                             }
1382                           if (a != NULL)
1383                             break;
1384                         }
1385                       if (verstr == NULL)
1386                         {
1387                           (*_bfd_error_handler)
1388                             (_("%s: %s: invalid needed version %d"),
1389                              bfd_get_filename (abfd), name, vernum);
1390                           bfd_set_error (bfd_error_bad_value);
1391                           goto error_return;
1392                         }
1393                     }
1394
1395                   namelen = strlen (name);
1396                   newlen = namelen + strlen (verstr) + 2;
1397                   if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
1398                     ++newlen;
1399
1400                   newname = (char *) bfd_alloc (abfd, newlen);
1401                   if (newname == NULL)
1402                     goto error_return;
1403                   strcpy (newname, name);
1404                   p = newname + namelen;
1405                   *p++ = ELF_VER_CHR;
1406                   if ((iver.vs_vers & VERSYM_HIDDEN) == 0)
1407                     *p++ = ELF_VER_CHR;
1408                   strcpy (p, verstr);
1409
1410                   name = newname;
1411                 }
1412             }
1413
1414           if (! elf_merge_symbol (abfd, info, name, &sym, &sec, &value,
1415                                   sym_hash, &override, &type_change_ok,
1416                                   &size_change_ok))
1417             goto error_return;
1418
1419           if (override)
1420             definition = false;
1421
1422           h = *sym_hash;
1423           while (h->root.type == bfd_link_hash_indirect
1424                  || h->root.type == bfd_link_hash_warning)
1425             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1426
1427           /* Remember the old alignment if this is a common symbol, so
1428              that we don't reduce the alignment later on.  We can't
1429              check later, because _bfd_generic_link_add_one_symbol
1430              will set a default for the alignment which we want to
1431              override.  */
1432           if (h->root.type == bfd_link_hash_common)
1433             old_alignment = h->root.u.c.p->alignment_power;
1434
1435           if (elf_tdata (abfd)->verdef != NULL
1436               && ! override
1437               && vernum > 1
1438               && definition)
1439             h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
1440         }
1441
1442       if (! (_bfd_generic_link_add_one_symbol
1443              (info, abfd, name, flags, sec, value, (const char *) NULL,
1444               false, collect, (struct bfd_link_hash_entry **) sym_hash)))
1445         goto error_return;
1446
1447       h = *sym_hash;
1448       while (h->root.type == bfd_link_hash_indirect
1449              || h->root.type == bfd_link_hash_warning)
1450         h = (struct elf_link_hash_entry *) h->root.u.i.link;
1451       *sym_hash = h;
1452
1453       new_weakdef = false;
1454       if (dynamic
1455           && definition
1456           && (flags & BSF_WEAK) != 0
1457           && ELF_ST_TYPE (sym.st_info) != STT_FUNC
1458           && info->hash->creator->flavour == bfd_target_elf_flavour
1459           && h->weakdef == NULL)
1460         {
1461           /* Keep a list of all weak defined non function symbols from
1462              a dynamic object, using the weakdef field.  Later in this
1463              function we will set the weakdef field to the correct
1464              value.  We only put non-function symbols from dynamic
1465              objects on this list, because that happens to be the only
1466              time we need to know the normal symbol corresponding to a
1467              weak symbol, and the information is time consuming to
1468              figure out.  If the weakdef field is not already NULL,
1469              then this symbol was already defined by some previous
1470              dynamic object, and we will be using that previous
1471              definition anyhow.  */
1472
1473           h->weakdef = weaks;
1474           weaks = h;
1475           new_weakdef = true;
1476         }
1477
1478       /* Set the alignment of a common symbol.  */
1479       if (sym.st_shndx == SHN_COMMON
1480           && h->root.type == bfd_link_hash_common)
1481         {
1482           unsigned int align;
1483
1484           align = bfd_log2 (sym.st_value);
1485           if (align > old_alignment)
1486             h->root.u.c.p->alignment_power = align;
1487         }
1488
1489       if (info->hash->creator->flavour == bfd_target_elf_flavour)
1490         {
1491           int old_flags;
1492           boolean dynsym;
1493           int new_flag;
1494
1495           /* Remember the symbol size and type.  */
1496           if (sym.st_size != 0
1497               && (definition || h->size == 0))
1498             {
1499               if (h->size != 0 && h->size != sym.st_size && ! size_change_ok)
1500                 (*_bfd_error_handler)
1501                   (_("Warning: size of symbol `%s' changed from %lu to %lu in %s"),
1502                    name, (unsigned long) h->size, (unsigned long) sym.st_size,
1503                    bfd_get_filename (abfd));
1504
1505               h->size = sym.st_size;
1506             }
1507
1508           /* If this is a common symbol, then we always want H->SIZE
1509              to be the size of the common symbol.  The code just above
1510              won't fix the size if a common symbol becomes larger.  We
1511              don't warn about a size change here, because that is
1512              covered by --warn-common.  */
1513           if (h->root.type == bfd_link_hash_common)
1514             h->size = h->root.u.c.size;
1515
1516           if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE
1517               && (definition || h->type == STT_NOTYPE))
1518             {
1519               if (h->type != STT_NOTYPE
1520                   && h->type != ELF_ST_TYPE (sym.st_info)
1521                   && ! type_change_ok)
1522                 (*_bfd_error_handler)
1523                   (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
1524                    name, h->type, ELF_ST_TYPE (sym.st_info),
1525                    bfd_get_filename (abfd));
1526
1527               h->type = ELF_ST_TYPE (sym.st_info);
1528             }
1529
1530           if (sym.st_other != 0
1531               && (definition || h->other == 0))
1532             h->other = sym.st_other;
1533
1534           /* Set a flag in the hash table entry indicating the type of
1535              reference or definition we just found.  Keep a count of
1536              the number of dynamic symbols we find.  A dynamic symbol
1537              is one which is referenced or defined by both a regular
1538              object and a shared object.  */
1539           old_flags = h->elf_link_hash_flags;
1540           dynsym = false;
1541           if (! dynamic)
1542             {
1543               if (! definition)
1544                 {
1545                   new_flag = ELF_LINK_HASH_REF_REGULAR;
1546                   if (bind != STB_WEAK)
1547                     new_flag |= ELF_LINK_HASH_REF_REGULAR_NONWEAK;
1548                 }
1549               else
1550                 new_flag = ELF_LINK_HASH_DEF_REGULAR;
1551               if (info->shared
1552                   || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1553                                    | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
1554                 dynsym = true;
1555             }
1556           else
1557             {
1558               if (! definition)
1559                 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
1560               else
1561                 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
1562               if ((old_flags & (ELF_LINK_HASH_DEF_REGULAR
1563                                 | ELF_LINK_HASH_REF_REGULAR)) != 0
1564                   || (h->weakdef != NULL
1565                       && ! new_weakdef
1566                       && h->weakdef->dynindx != -1))
1567                 dynsym = true;
1568             }
1569
1570           h->elf_link_hash_flags |= new_flag;
1571
1572           /* If this symbol has a version, and it is the default
1573              version, we create an indirect symbol from the default
1574              name to the fully decorated name.  This will cause
1575              external references which do not specify a version to be
1576              bound to this version of the symbol.  */
1577           if (definition)
1578             {
1579               char *p;
1580
1581               p = strchr (name, ELF_VER_CHR);
1582               if (p != NULL && p[1] == ELF_VER_CHR)
1583                 {
1584                   char *shortname;
1585                   struct elf_link_hash_entry *hi;
1586                   boolean override;
1587
1588                   shortname = bfd_hash_allocate (&info->hash->table,
1589                                                  p - name + 1);
1590                   if (shortname == NULL)
1591                     goto error_return;
1592                   strncpy (shortname, name, p - name);
1593                   shortname[p - name] = '\0';
1594
1595                   /* We are going to create a new symbol.  Merge it
1596                      with any existing symbol with this name.  For the
1597                      purposes of the merge, act as though we were
1598                      defining the symbol we just defined, although we
1599                      actually going to define an indirect symbol.  */
1600                   type_change_ok = false;
1601                   size_change_ok = false;
1602                   if (! elf_merge_symbol (abfd, info, shortname, &sym, &sec,
1603                                           &value, &hi, &override,
1604                                           &type_change_ok, &size_change_ok))
1605                     goto error_return;
1606
1607                   if (! override)
1608                     {
1609                       if (! (_bfd_generic_link_add_one_symbol
1610                              (info, abfd, shortname, BSF_INDIRECT,
1611                               bfd_ind_section_ptr, (bfd_vma) 0, name, false,
1612                               collect, (struct bfd_link_hash_entry **) &hi)))
1613                         goto error_return;
1614                     }
1615                   else
1616                     {
1617                       /* In this case the symbol named SHORTNAME is
1618                          overriding the indirect symbol we want to
1619                          add.  We were planning on making SHORTNAME an
1620                          indirect symbol referring to NAME.  SHORTNAME
1621                          is the name without a version.  NAME is the
1622                          fully versioned name, and it is the default
1623                          version.
1624
1625                          Overriding means that we already saw a
1626                          definition for the symbol SHORTNAME in a
1627                          regular object, and it is overriding the
1628                          symbol defined in the dynamic object.
1629
1630                          When this happens, we actually want to change
1631                          NAME, the symbol we just added, to refer to
1632                          SHORTNAME.  This will cause references to
1633                          NAME in the shared object to become
1634                          references to SHORTNAME in the regular
1635                          object.  This is what we expect when we
1636                          override a function in a shared object: that
1637                          the references in the shared object will be
1638                          mapped to the definition in the regular
1639                          object.  */
1640
1641                       while (hi->root.type == bfd_link_hash_indirect
1642                              || hi->root.type == bfd_link_hash_warning)
1643                         hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1644
1645                       h->root.type = bfd_link_hash_indirect;
1646                       h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1647                       if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
1648                         {
1649                           h->elf_link_hash_flags &=~ ELF_LINK_HASH_DEF_DYNAMIC;
1650                           hi->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
1651                           if (hi->elf_link_hash_flags
1652                               & (ELF_LINK_HASH_REF_REGULAR
1653                                  | ELF_LINK_HASH_DEF_REGULAR))
1654                             {
1655                               if (! _bfd_elf_link_record_dynamic_symbol (info,
1656                                                                          hi))
1657                                 goto error_return;
1658                             }
1659                         }
1660
1661                       /* Now set HI to H, so that the following code
1662                          will set the other fields correctly.  */
1663                       hi = h;
1664                     }
1665
1666                   /* If there is a duplicate definition somewhere,
1667                      then HI may not point to an indirect symbol.  We
1668                      will have reported an error to the user in that
1669                      case.  */
1670
1671                   if (hi->root.type == bfd_link_hash_indirect)
1672                     {
1673                       struct elf_link_hash_entry *ht;
1674
1675                       /* If the symbol became indirect, then we assume
1676                          that we have not seen a definition before.  */
1677                       BFD_ASSERT ((hi->elf_link_hash_flags
1678                                    & (ELF_LINK_HASH_DEF_DYNAMIC
1679                                       | ELF_LINK_HASH_DEF_REGULAR))
1680                                   == 0);
1681
1682                       ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1683
1684                       /* Copy down any references that we may have
1685                          already seen to the symbol which just became
1686                          indirect.  */
1687                       ht->elf_link_hash_flags |=
1688                         (hi->elf_link_hash_flags
1689                          & (ELF_LINK_HASH_REF_DYNAMIC
1690                             | ELF_LINK_HASH_REF_REGULAR
1691                             | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1692                             | ELF_LINK_NON_GOT_REF));
1693
1694                       /* Copy over the global and procedure linkage table
1695                          offset entries.  These may have been already set
1696                          up by a check_relocs routine.  */
1697                       if (ht->got.offset == (bfd_vma) -1)
1698                         {
1699                           ht->got.offset = hi->got.offset;
1700                           hi->got.offset = (bfd_vma) -1;
1701                         }
1702                       BFD_ASSERT (hi->got.offset == (bfd_vma) -1);
1703
1704                       if (ht->plt.offset == (bfd_vma) -1)
1705                         {
1706                           ht->plt.offset = hi->plt.offset;
1707                           hi->plt.offset = (bfd_vma) -1;
1708                         }
1709                       BFD_ASSERT (hi->plt.offset == (bfd_vma) -1);
1710
1711                       if (ht->dynindx == -1)
1712                         {
1713                           ht->dynindx = hi->dynindx;
1714                           ht->dynstr_index = hi->dynstr_index;
1715                           hi->dynindx = -1;
1716                           hi->dynstr_index = 0;
1717                         }
1718                       BFD_ASSERT (hi->dynindx == -1);
1719
1720                       /* FIXME: There may be other information to copy
1721                          over for particular targets.  */
1722
1723                       /* See if the new flags lead us to realize that
1724                          the symbol must be dynamic.  */
1725                       if (! dynsym)
1726                         {
1727                           if (! dynamic)
1728                             {
1729                               if (info->shared
1730                                   || ((hi->elf_link_hash_flags
1731                                        & ELF_LINK_HASH_REF_DYNAMIC)
1732                                       != 0))
1733                                 dynsym = true;
1734                             }
1735                           else
1736                             {
1737                               if ((hi->elf_link_hash_flags
1738                                    & ELF_LINK_HASH_REF_REGULAR) != 0)
1739                                 dynsym = true;
1740                             }
1741                         }
1742                     }
1743
1744                   /* We also need to define an indirection from the
1745                      nondefault version of the symbol.  */
1746
1747                   shortname = bfd_hash_allocate (&info->hash->table,
1748                                                  strlen (name));
1749                   if (shortname == NULL)
1750                     goto error_return;
1751                   strncpy (shortname, name, p - name);
1752                   strcpy (shortname + (p - name), p + 1);
1753
1754                   /* Once again, merge with any existing symbol.  */
1755                   type_change_ok = false;
1756                   size_change_ok = false;
1757                   if (! elf_merge_symbol (abfd, info, shortname, &sym, &sec,
1758                                           &value, &hi, &override,
1759                                           &type_change_ok, &size_change_ok))
1760                     goto error_return;
1761
1762                   if (override)
1763                     {
1764                       /* Here SHORTNAME is a versioned name, so we
1765                          don't expect to see the type of override we
1766                          do in the case above.  */
1767                       (*_bfd_error_handler)
1768                         (_("%s: warning: unexpected redefinition of `%s'"),
1769                          bfd_get_filename (abfd), shortname);
1770                     }
1771                   else
1772                     {
1773                       if (! (_bfd_generic_link_add_one_symbol
1774                              (info, abfd, shortname, BSF_INDIRECT,
1775                               bfd_ind_section_ptr, (bfd_vma) 0, name, false,
1776                               collect, (struct bfd_link_hash_entry **) &hi)))
1777                         goto error_return;
1778
1779                       /* If there is a duplicate definition somewhere,
1780                          then HI may not point to an indirect symbol.
1781                          We will have reported an error to the user in
1782                          that case.  */
1783
1784                       if (hi->root.type == bfd_link_hash_indirect)
1785                         {
1786                           /* If the symbol became indirect, then we
1787                              assume that we have not seen a definition
1788                              before.  */
1789                           BFD_ASSERT ((hi->elf_link_hash_flags
1790                                        & (ELF_LINK_HASH_DEF_DYNAMIC
1791                                           | ELF_LINK_HASH_DEF_REGULAR))
1792                                       == 0);
1793
1794                           /* Copy down any references that we may have
1795                              already seen to the symbol which just
1796                              became indirect.  */
1797                           h->elf_link_hash_flags |=
1798                             (hi->elf_link_hash_flags
1799                              & (ELF_LINK_HASH_REF_DYNAMIC
1800                                 | ELF_LINK_HASH_REF_REGULAR
1801                                 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1802                                 | ELF_LINK_NON_GOT_REF));
1803
1804                           /* Copy over the global and procedure linkage
1805                              table offset entries.  These may have been
1806                              already set up by a check_relocs routine.  */
1807                           if (h->got.offset == (bfd_vma) -1)
1808                             {
1809                               h->got.offset = hi->got.offset;
1810                               hi->got.offset = (bfd_vma) -1;
1811                             }
1812                           BFD_ASSERT (hi->got.offset == (bfd_vma) -1);
1813
1814                           if (h->plt.offset == (bfd_vma) -1)
1815                             {
1816                               h->plt.offset = hi->plt.offset;
1817                               hi->plt.offset = (bfd_vma) -1;
1818                             }
1819                           BFD_ASSERT (hi->got.offset == (bfd_vma) -1);
1820
1821                           if (h->dynindx == -1)
1822                             {
1823                               h->dynindx = hi->dynindx;
1824                               h->dynstr_index = hi->dynstr_index;
1825                               hi->dynindx = -1;
1826                               hi->dynstr_index = 0;
1827                             }
1828                           BFD_ASSERT (hi->dynindx == -1);
1829
1830                           /* FIXME: There may be other information to
1831                              copy over for particular targets.  */
1832
1833                           /* See if the new flags lead us to realize
1834                              that the symbol must be dynamic.  */
1835                           if (! dynsym)
1836                             {
1837                               if (! dynamic)
1838                                 {
1839                                   if (info->shared
1840                                       || ((hi->elf_link_hash_flags
1841                                            & ELF_LINK_HASH_REF_DYNAMIC)
1842                                           != 0))
1843                                     dynsym = true;
1844                                 }
1845                               else
1846                                 {
1847                                   if ((hi->elf_link_hash_flags
1848                                        & ELF_LINK_HASH_REF_REGULAR) != 0)
1849                                     dynsym = true;
1850                                 }
1851                             }
1852                         }
1853                     }
1854                 }
1855             }
1856
1857           if (dynsym && h->dynindx == -1)
1858             {
1859               if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1860                 goto error_return;
1861               if (h->weakdef != NULL
1862                   && ! new_weakdef
1863                   && h->weakdef->dynindx == -1)
1864                 {
1865                   if (! _bfd_elf_link_record_dynamic_symbol (info,
1866                                                              h->weakdef))
1867                     goto error_return;
1868                 }
1869             }
1870         }
1871     }
1872
1873   /* Now set the weakdefs field correctly for all the weak defined
1874      symbols we found.  The only way to do this is to search all the
1875      symbols.  Since we only need the information for non functions in
1876      dynamic objects, that's the only time we actually put anything on
1877      the list WEAKS.  We need this information so that if a regular
1878      object refers to a symbol defined weakly in a dynamic object, the
1879      real symbol in the dynamic object is also put in the dynamic
1880      symbols; we also must arrange for both symbols to point to the
1881      same memory location.  We could handle the general case of symbol
1882      aliasing, but a general symbol alias can only be generated in
1883      assembler code, handling it correctly would be very time
1884      consuming, and other ELF linkers don't handle general aliasing
1885      either.  */
1886   while (weaks != NULL)
1887     {
1888       struct elf_link_hash_entry *hlook;
1889       asection *slook;
1890       bfd_vma vlook;
1891       struct elf_link_hash_entry **hpp;
1892       struct elf_link_hash_entry **hppend;
1893
1894       hlook = weaks;
1895       weaks = hlook->weakdef;
1896       hlook->weakdef = NULL;
1897
1898       BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
1899                   || hlook->root.type == bfd_link_hash_defweak
1900                   || hlook->root.type == bfd_link_hash_common
1901                   || hlook->root.type == bfd_link_hash_indirect);
1902       slook = hlook->root.u.def.section;
1903       vlook = hlook->root.u.def.value;
1904
1905       hpp = elf_sym_hashes (abfd);
1906       hppend = hpp + extsymcount;
1907       for (; hpp < hppend; hpp++)
1908         {
1909           struct elf_link_hash_entry *h;
1910
1911           h = *hpp;
1912           if (h != NULL && h != hlook
1913               && h->root.type == bfd_link_hash_defined
1914               && h->root.u.def.section == slook
1915               && h->root.u.def.value == vlook)
1916             {
1917               hlook->weakdef = h;
1918
1919               /* If the weak definition is in the list of dynamic
1920                  symbols, make sure the real definition is put there
1921                  as well.  */
1922               if (hlook->dynindx != -1
1923                   && h->dynindx == -1)
1924                 {
1925                   if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1926                     goto error_return;
1927                 }
1928
1929               /* If the real definition is in the list of dynamic
1930                  symbols, make sure the weak definition is put there
1931                  as well.  If we don't do this, then the dynamic
1932                  loader might not merge the entries for the real
1933                  definition and the weak definition.  */
1934               if (h->dynindx != -1
1935                   && hlook->dynindx == -1)
1936                 {
1937                   if (! _bfd_elf_link_record_dynamic_symbol (info, hlook))
1938                     goto error_return;
1939                 }
1940
1941               break;
1942             }
1943         }
1944     }
1945
1946   if (buf != NULL)
1947     {
1948       free (buf);
1949       buf = NULL;
1950     }
1951
1952   if (extversym != NULL)
1953     {
1954       free (extversym);
1955       extversym = NULL;
1956     }
1957
1958   /* If this object is the same format as the output object, and it is
1959      not a shared library, then let the backend look through the
1960      relocs.
1961
1962      This is required to build global offset table entries and to
1963      arrange for dynamic relocs.  It is not required for the
1964      particular common case of linking non PIC code, even when linking
1965      against shared libraries, but unfortunately there is no way of
1966      knowing whether an object file has been compiled PIC or not.
1967      Looking through the relocs is not particularly time consuming.
1968      The problem is that we must either (1) keep the relocs in memory,
1969      which causes the linker to require additional runtime memory or
1970      (2) read the relocs twice from the input file, which wastes time.
1971      This would be a good case for using mmap.
1972
1973      I have no idea how to handle linking PIC code into a file of a
1974      different format.  It probably can't be done.  */
1975   check_relocs = get_elf_backend_data (abfd)->check_relocs;
1976   if (! dynamic
1977       && abfd->xvec == info->hash->creator
1978       && check_relocs != NULL)
1979     {
1980       asection *o;
1981
1982       for (o = abfd->sections; o != NULL; o = o->next)
1983         {
1984           Elf_Internal_Rela *internal_relocs;
1985           boolean ok;
1986
1987           if ((o->flags & SEC_RELOC) == 0
1988               || o->reloc_count == 0
1989               || ((info->strip == strip_all || info->strip == strip_debugger)
1990                   && (o->flags & SEC_DEBUGGING) != 0)
1991               || bfd_is_abs_section (o->output_section))
1992             continue;
1993
1994           internal_relocs = (NAME(_bfd_elf,link_read_relocs)
1995                              (abfd, o, (PTR) NULL,
1996                               (Elf_Internal_Rela *) NULL,
1997                               info->keep_memory));
1998           if (internal_relocs == NULL)
1999             goto error_return;
2000
2001           ok = (*check_relocs) (abfd, info, o, internal_relocs);
2002
2003           if (! info->keep_memory)
2004             free (internal_relocs);
2005
2006           if (! ok)
2007             goto error_return;
2008         }
2009     }
2010
2011   /* If this is a non-traditional, non-relocateable link, try to
2012      optimize the handling of the .stab/.stabstr sections.  */
2013   if (! dynamic
2014       && ! info->relocateable
2015       && ! info->traditional_format
2016       && info->hash->creator->flavour == bfd_target_elf_flavour
2017       && (info->strip != strip_all && info->strip != strip_debugger))
2018     {
2019       asection *stab, *stabstr;
2020
2021       stab = bfd_get_section_by_name (abfd, ".stab");
2022       if (stab != NULL)
2023         {
2024           stabstr = bfd_get_section_by_name (abfd, ".stabstr");
2025
2026           if (stabstr != NULL)
2027             {
2028               struct bfd_elf_section_data *secdata;
2029
2030               secdata = elf_section_data (stab);
2031               if (! _bfd_link_section_stabs (abfd,
2032                                              &elf_hash_table (info)->stab_info,
2033                                              stab, stabstr,
2034                                              &secdata->stab_info))
2035                 goto error_return;
2036             }
2037         }
2038     }
2039
2040   return true;
2041
2042  error_return:
2043   if (buf != NULL)
2044     free (buf);
2045   if (dynbuf != NULL)
2046     free (dynbuf);
2047   if (dynver != NULL)
2048     free (dynver);
2049   if (extversym != NULL)
2050     free (extversym);
2051   return false;
2052 }
2053
2054 /* Create some sections which will be filled in with dynamic linking
2055    information.  ABFD is an input file which requires dynamic sections
2056    to be created.  The dynamic sections take up virtual memory space
2057    when the final executable is run, so we need to create them before
2058    addresses are assigned to the output sections.  We work out the
2059    actual contents and size of these sections later.  */
2060
2061 boolean
2062 elf_link_create_dynamic_sections (abfd, info)
2063      bfd *abfd;
2064      struct bfd_link_info *info;
2065 {
2066   flagword flags;
2067   register asection *s;
2068   struct elf_link_hash_entry *h;
2069   struct elf_backend_data *bed;
2070
2071   if (elf_hash_table (info)->dynamic_sections_created)
2072     return true;
2073
2074   /* Make sure that all dynamic sections use the same input BFD.  */
2075   if (elf_hash_table (info)->dynobj == NULL)
2076     elf_hash_table (info)->dynobj = abfd;
2077   else
2078     abfd = elf_hash_table (info)->dynobj;
2079
2080   /* Note that we set the SEC_IN_MEMORY flag for all of these
2081      sections.  */
2082   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2083            | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2084
2085   /* A dynamically linked executable has a .interp section, but a
2086      shared library does not.  */
2087   if (! info->shared)
2088     {
2089       s = bfd_make_section (abfd, ".interp");
2090       if (s == NULL
2091           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
2092         return false;
2093     }
2094
2095   /* Create sections to hold version informations.  These are removed
2096      if they are not needed.  */
2097   s = bfd_make_section (abfd, ".gnu.version_d");
2098   if (s == NULL
2099       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2100       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2101     return false;
2102
2103   s = bfd_make_section (abfd, ".gnu.version");
2104   if (s == NULL
2105       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2106       || ! bfd_set_section_alignment (abfd, s, 1))
2107     return false;
2108
2109   s = bfd_make_section (abfd, ".gnu.version_r");
2110   if (s == NULL
2111       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2112       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2113     return false;
2114
2115   s = bfd_make_section (abfd, ".dynsym");
2116   if (s == NULL
2117       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2118       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2119     return false;
2120
2121   s = bfd_make_section (abfd, ".dynstr");
2122   if (s == NULL
2123       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
2124     return false;
2125
2126   /* Create a strtab to hold the dynamic symbol names.  */
2127   if (elf_hash_table (info)->dynstr == NULL)
2128     {
2129       elf_hash_table (info)->dynstr = elf_stringtab_init ();
2130       if (elf_hash_table (info)->dynstr == NULL)
2131         return false;
2132     }
2133
2134   s = bfd_make_section (abfd, ".dynamic");
2135   if (s == NULL
2136       || ! bfd_set_section_flags (abfd, s, flags)
2137       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2138     return false;
2139
2140   /* The special symbol _DYNAMIC is always set to the start of the
2141      .dynamic section.  This call occurs before we have processed the
2142      symbols for any dynamic object, so we don't have to worry about
2143      overriding a dynamic definition.  We could set _DYNAMIC in a
2144      linker script, but we only want to define it if we are, in fact,
2145      creating a .dynamic section.  We don't want to define it if there
2146      is no .dynamic section, since on some ELF platforms the start up
2147      code examines it to decide how to initialize the process.  */
2148   h = NULL;
2149   if (! (_bfd_generic_link_add_one_symbol
2150          (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
2151           (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
2152           (struct bfd_link_hash_entry **) &h)))
2153     return false;
2154   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2155   h->type = STT_OBJECT;
2156
2157   if (info->shared
2158       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2159     return false;
2160
2161   bed = get_elf_backend_data (abfd);
2162
2163   s = bfd_make_section (abfd, ".hash");
2164   if (s == NULL
2165       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2166       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
2167     return false;
2168   elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
2169
2170   /* Let the backend create the rest of the sections.  This lets the
2171      backend set the right flags.  The backend will normally create
2172      the .got and .plt sections.  */
2173   if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
2174     return false;
2175
2176   elf_hash_table (info)->dynamic_sections_created = true;
2177
2178   return true;
2179 }
2180
2181 /* Add an entry to the .dynamic table.  */
2182
2183 boolean
2184 elf_add_dynamic_entry (info, tag, val)
2185      struct bfd_link_info *info;
2186      bfd_vma tag;
2187      bfd_vma val;
2188 {
2189   Elf_Internal_Dyn dyn;
2190   bfd *dynobj;
2191   asection *s;
2192   size_t newsize;
2193   bfd_byte *newcontents;
2194
2195   dynobj = elf_hash_table (info)->dynobj;
2196
2197   s = bfd_get_section_by_name (dynobj, ".dynamic");
2198   BFD_ASSERT (s != NULL);
2199
2200   newsize = s->_raw_size + sizeof (Elf_External_Dyn);
2201   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
2202   if (newcontents == NULL)
2203     return false;
2204
2205   dyn.d_tag = tag;
2206   dyn.d_un.d_val = val;
2207   elf_swap_dyn_out (dynobj, &dyn,
2208                     (Elf_External_Dyn *) (newcontents + s->_raw_size));
2209
2210   s->_raw_size = newsize;
2211   s->contents = newcontents;
2212
2213   return true;
2214 }
2215
2216 /* Record a new local dynamic symbol.  */
2217
2218 boolean
2219 elf_link_record_local_dynamic_symbol (info, input_bfd, input_indx)
2220      struct bfd_link_info *info;
2221      bfd *input_bfd;
2222      long input_indx;
2223 {
2224   struct elf_link_local_dynamic_entry *entry;
2225   struct elf_link_hash_table *eht;
2226   struct bfd_strtab_hash *dynstr;
2227   Elf_External_Sym esym;
2228   unsigned long dynstr_index;
2229   char *name;
2230
2231   /* See if the entry exists already.  */
2232   for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
2233     if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
2234       return true;
2235
2236   entry = (struct elf_link_local_dynamic_entry *)
2237     bfd_alloc (input_bfd, sizeof (*entry));
2238   if (entry == NULL)
2239     return false;
2240
2241   /* Go find the symbol, so that we can find it's name.  */
2242   if (bfd_seek (input_bfd,
2243                 (elf_tdata (input_bfd)->symtab_hdr.sh_offset
2244                  + input_indx * sizeof (Elf_External_Sym)),
2245                 SEEK_SET) != 0
2246       || (bfd_read (&esym, sizeof (Elf_External_Sym), 1, input_bfd)
2247           != sizeof (Elf_External_Sym)))
2248     return false;
2249   elf_swap_symbol_in (input_bfd, &esym, &entry->isym);
2250
2251   name = (bfd_elf_string_from_elf_section
2252           (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
2253            entry->isym.st_name));
2254
2255   dynstr = elf_hash_table (info)->dynstr;
2256   if (dynstr == NULL)
2257     {
2258       /* Create a strtab to hold the dynamic symbol names.  */
2259       elf_hash_table (info)->dynstr = dynstr = _bfd_elf_stringtab_init ();
2260       if (dynstr == NULL)
2261         return false;
2262     }
2263
2264   dynstr_index = _bfd_stringtab_add (dynstr, name, true, false);
2265   if (dynstr_index == (unsigned long) -1)
2266     return false;
2267   entry->isym.st_name = dynstr_index;
2268
2269   eht = elf_hash_table (info);
2270
2271   entry->next = eht->dynlocal;
2272   eht->dynlocal = entry;
2273   entry->input_bfd = input_bfd;
2274   entry->input_indx = input_indx;
2275   eht->dynsymcount++;
2276
2277   /* Whatever binding the symbol had before, it's now local.  */
2278   entry->isym.st_info
2279     = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
2280
2281   /* The dynindx will be set at the end of size_dynamic_sections.  */
2282
2283   return true;
2284 }
2285 \f
2286
2287 /* Read and swap the relocs from the section indicated by SHDR.  This
2288    may be either a REL or a RELA section.  The relocations are
2289    translated into RELA relocations and stored in INTERNAL_RELOCS,
2290    which should have already been allocated to contain enough space.
2291    The EXTERNAL_RELOCS are a buffer where the external form of the
2292    relocations should be stored.
2293
2294    Returns false if something goes wrong.  */
2295
2296 static boolean
2297 elf_link_read_relocs_from_section (abfd, shdr, external_relocs,
2298                                    internal_relocs)
2299      bfd *abfd;
2300      Elf_Internal_Shdr *shdr;
2301      PTR external_relocs;
2302      Elf_Internal_Rela *internal_relocs;
2303 {
2304   struct elf_backend_data *bed;
2305
2306   /* If there aren't any relocations, that's OK.  */
2307   if (!shdr)
2308     return true;
2309
2310   /* Position ourselves at the start of the section.  */
2311   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2312     return false;
2313
2314   /* Read the relocations.  */
2315   if (bfd_read (external_relocs, 1, shdr->sh_size, abfd)
2316       != shdr->sh_size)
2317     return false;
2318
2319   bed = get_elf_backend_data (abfd);
2320
2321   /* Convert the external relocations to the internal format.  */
2322   if (shdr->sh_entsize == sizeof (Elf_External_Rel))
2323     {
2324       Elf_External_Rel *erel;
2325       Elf_External_Rel *erelend;
2326       Elf_Internal_Rela *irela;
2327       Elf_Internal_Rel *irel;
2328
2329       erel = (Elf_External_Rel *) external_relocs;
2330       erelend = erel + shdr->sh_size / shdr->sh_entsize;
2331       irela = internal_relocs;
2332       irel = bfd_alloc (abfd, (bed->s->int_rels_per_ext_rel
2333                                * sizeof (Elf_Internal_Rel)));
2334       for (; erel < erelend; erel++, irela += bed->s->int_rels_per_ext_rel)
2335         {
2336           unsigned char i;
2337
2338           if (bed->s->swap_reloc_in)
2339             (*bed->s->swap_reloc_in) (abfd, (bfd_byte *) erel, irel);
2340           else
2341             elf_swap_reloc_in (abfd, erel, irel);
2342
2343           for (i = 0; i < bed->s->int_rels_per_ext_rel; ++i)
2344             {
2345               irela[i].r_offset = irel[i].r_offset;
2346               irela[i].r_info = irel[i].r_info;
2347               irela[i].r_addend = 0;
2348             }
2349         }
2350     }
2351   else
2352     {
2353       Elf_External_Rela *erela;
2354       Elf_External_Rela *erelaend;
2355       Elf_Internal_Rela *irela;
2356
2357       BFD_ASSERT (shdr->sh_entsize == sizeof (Elf_External_Rela));
2358
2359       erela = (Elf_External_Rela *) external_relocs;
2360       erelaend = erela + shdr->sh_size / shdr->sh_entsize;
2361       irela = internal_relocs;
2362       for (; erela < erelaend; erela++, irela += bed->s->int_rels_per_ext_rel)
2363         {
2364           if (bed->s->swap_reloca_in)
2365             (*bed->s->swap_reloca_in) (abfd, (bfd_byte *) erela, irela);
2366           else
2367             elf_swap_reloca_in (abfd, erela, irela);
2368         }
2369     }
2370
2371   return true;
2372 }
2373
2374 /* Read and swap the relocs for a section O.  They may have been
2375    cached.  If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2376    not NULL, they are used as buffers to read into.  They are known to
2377    be large enough.  If the INTERNAL_RELOCS relocs argument is NULL,
2378    the return value is allocated using either malloc or bfd_alloc,
2379    according to the KEEP_MEMORY argument.  If O has two relocation
2380    sections (both REL and RELA relocations), then the REL_HDR
2381    relocations will appear first in INTERNAL_RELOCS, followed by the
2382    REL_HDR2 relocations.  */
2383
2384 Elf_Internal_Rela *
2385 NAME(_bfd_elf,link_read_relocs) (abfd, o, external_relocs, internal_relocs,
2386                                  keep_memory)
2387      bfd *abfd;
2388      asection *o;
2389      PTR external_relocs;
2390      Elf_Internal_Rela *internal_relocs;
2391      boolean keep_memory;
2392 {
2393   Elf_Internal_Shdr *rel_hdr;
2394   PTR alloc1 = NULL;
2395   Elf_Internal_Rela *alloc2 = NULL;
2396   struct elf_backend_data *bed = get_elf_backend_data (abfd);
2397
2398   if (elf_section_data (o)->relocs != NULL)
2399     return elf_section_data (o)->relocs;
2400
2401   if (o->reloc_count == 0)
2402     return NULL;
2403
2404   rel_hdr = &elf_section_data (o)->rel_hdr;
2405
2406   if (internal_relocs == NULL)
2407     {
2408       size_t size;
2409
2410       size = (o->reloc_count * bed->s->int_rels_per_ext_rel
2411               * sizeof (Elf_Internal_Rela));
2412       if (keep_memory)
2413         internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2414       else
2415         internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2416       if (internal_relocs == NULL)
2417         goto error_return;
2418     }
2419
2420   if (external_relocs == NULL)
2421     {
2422       size_t size = (size_t) rel_hdr->sh_size;
2423
2424       if (elf_section_data (o)->rel_hdr2)
2425         size += (size_t) elf_section_data (o)->rel_hdr2->sh_size;
2426       alloc1 = (PTR) bfd_malloc (size);
2427       if (alloc1 == NULL)
2428         goto error_return;
2429       external_relocs = alloc1;
2430     }
2431
2432   if (!elf_link_read_relocs_from_section (abfd, rel_hdr,
2433                                           external_relocs,
2434                                           internal_relocs))
2435     goto error_return;
2436   if (!elf_link_read_relocs_from_section
2437       (abfd,
2438        elf_section_data (o)->rel_hdr2,
2439        ((bfd_byte *) external_relocs) + rel_hdr->sh_size,
2440        internal_relocs + (rel_hdr->sh_size / rel_hdr->sh_entsize
2441                           * bed->s->int_rels_per_ext_rel)))
2442     goto error_return;
2443
2444   /* Cache the results for next time, if we can.  */
2445   if (keep_memory)
2446     elf_section_data (o)->relocs = internal_relocs;
2447
2448   if (alloc1 != NULL)
2449     free (alloc1);
2450
2451   /* Don't free alloc2, since if it was allocated we are passing it
2452      back (under the name of internal_relocs).  */
2453
2454   return internal_relocs;
2455
2456  error_return:
2457   if (alloc1 != NULL)
2458     free (alloc1);
2459   if (alloc2 != NULL)
2460     free (alloc2);
2461   return NULL;
2462 }
2463 \f
2464
2465 /* Record an assignment to a symbol made by a linker script.  We need
2466    this in case some dynamic object refers to this symbol.  */
2467
2468 /*ARGSUSED*/
2469 boolean
2470 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
2471      bfd *output_bfd ATTRIBUTE_UNUSED;
2472      struct bfd_link_info *info;
2473      const char *name;
2474      boolean provide;
2475 {
2476   struct elf_link_hash_entry *h;
2477
2478   if (info->hash->creator->flavour != bfd_target_elf_flavour)
2479     return true;
2480
2481   h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
2482   if (h == NULL)
2483     return false;
2484
2485   if (h->root.type == bfd_link_hash_new)
2486     h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
2487
2488   /* If this symbol is being provided by the linker script, and it is
2489      currently defined by a dynamic object, but not by a regular
2490      object, then mark it as undefined so that the generic linker will
2491      force the correct value.  */
2492   if (provide
2493       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2494       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2495     h->root.type = bfd_link_hash_undefined;
2496
2497   /* If this symbol is not being provided by the linker script, and it is
2498      currently defined by a dynamic object, but not by a regular object,
2499      then clear out any version information because the symbol will not be
2500      associated with the dynamic object any more.  */
2501   if (!provide
2502       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2503       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2504     h->verinfo.verdef = NULL;
2505
2506   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2507
2508   /* When possible, keep the original type of the symbol */
2509   if (h->type == STT_NOTYPE)
2510     h->type = STT_OBJECT;
2511
2512   if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
2513                                   | ELF_LINK_HASH_REF_DYNAMIC)) != 0
2514        || info->shared)
2515       && h->dynindx == -1)
2516     {
2517       if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2518         return false;
2519
2520       /* If this is a weak defined symbol, and we know a corresponding
2521          real symbol from the same dynamic object, make sure the real
2522          symbol is also made into a dynamic symbol.  */
2523       if (h->weakdef != NULL
2524           && h->weakdef->dynindx == -1)
2525         {
2526           if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
2527             return false;
2528         }
2529     }
2530
2531   return true;
2532 }
2533 \f
2534 /* This structure is used to pass information to
2535    elf_link_assign_sym_version.  */
2536
2537 struct elf_assign_sym_version_info
2538 {
2539   /* Output BFD.  */
2540   bfd *output_bfd;
2541   /* General link information.  */
2542   struct bfd_link_info *info;
2543   /* Version tree.  */
2544   struct bfd_elf_version_tree *verdefs;
2545   /* Whether we are exporting all dynamic symbols.  */
2546   boolean export_dynamic;
2547   /* Whether we had a failure.  */
2548   boolean failed;
2549 };
2550
2551 /* This structure is used to pass information to
2552    elf_link_find_version_dependencies.  */
2553
2554 struct elf_find_verdep_info
2555 {
2556   /* Output BFD.  */
2557   bfd *output_bfd;
2558   /* General link information.  */
2559   struct bfd_link_info *info;
2560   /* The number of dependencies.  */
2561   unsigned int vers;
2562   /* Whether we had a failure.  */
2563   boolean failed;
2564 };
2565
2566 /* Array used to determine the number of hash table buckets to use
2567    based on the number of symbols there are.  If there are fewer than
2568    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
2569    fewer than 37 we use 17 buckets, and so forth.  We never use more
2570    than 32771 buckets.  */
2571
2572 static const size_t elf_buckets[] =
2573 {
2574   1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
2575   16411, 32771, 0
2576 };
2577
2578 /* Compute bucket count for hashing table.  We do not use a static set
2579    of possible tables sizes anymore.  Instead we determine for all
2580    possible reasonable sizes of the table the outcome (i.e., the
2581    number of collisions etc) and choose the best solution.  The
2582    weighting functions are not too simple to allow the table to grow
2583    without bounds.  Instead one of the weighting factors is the size.
2584    Therefore the result is always a good payoff between few collisions
2585    (= short chain lengths) and table size.  */
2586 static size_t
2587 compute_bucket_count (info)
2588      struct bfd_link_info *info;
2589 {
2590   size_t dynsymcount = elf_hash_table (info)->dynsymcount;
2591   size_t best_size = 0;
2592   unsigned long int *hashcodes;
2593   unsigned long int *hashcodesp;
2594   unsigned long int i;
2595
2596   /* Compute the hash values for all exported symbols.  At the same
2597      time store the values in an array so that we could use them for
2598      optimizations.  */
2599   hashcodes = (unsigned long int *) bfd_malloc (dynsymcount
2600                                                 * sizeof (unsigned long int));
2601   if (hashcodes == NULL)
2602     return 0;
2603   hashcodesp = hashcodes;
2604
2605   /* Put all hash values in HASHCODES.  */
2606   elf_link_hash_traverse (elf_hash_table (info),
2607                           elf_collect_hash_codes, &hashcodesp);
2608
2609 /* We have a problem here.  The following code to optimize the table
2610    size requires an integer type with more the 32 bits.  If
2611    BFD_HOST_U_64_BIT is set we know about such a type.  */
2612 #ifdef BFD_HOST_U_64_BIT
2613   if (info->optimize == true)
2614     {
2615       unsigned long int nsyms = hashcodesp - hashcodes;
2616       size_t minsize;
2617       size_t maxsize;
2618       BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
2619       unsigned long int *counts ;
2620
2621       /* Possible optimization parameters: if we have NSYMS symbols we say
2622          that the hashing table must at least have NSYMS/4 and at most
2623          2*NSYMS buckets.  */
2624       minsize = nsyms / 4;
2625       if (minsize == 0)
2626         minsize = 1;
2627       best_size = maxsize = nsyms * 2;
2628
2629       /* Create array where we count the collisions in.  We must use bfd_malloc
2630          since the size could be large.  */
2631       counts = (unsigned long int *) bfd_malloc (maxsize
2632                                                  * sizeof (unsigned long int));
2633       if (counts == NULL)
2634         {
2635           free (hashcodes);
2636           return 0;
2637         }
2638
2639       /* Compute the "optimal" size for the hash table.  The criteria is a
2640          minimal chain length.  The minor criteria is (of course) the size
2641          of the table.  */
2642       for (i = minsize; i < maxsize; ++i)
2643         {
2644           /* Walk through the array of hashcodes and count the collisions.  */
2645           BFD_HOST_U_64_BIT max;
2646           unsigned long int j;
2647           unsigned long int fact;
2648
2649           memset (counts, '\0', i * sizeof (unsigned long int));
2650
2651           /* Determine how often each hash bucket is used.  */
2652           for (j = 0; j < nsyms; ++j)
2653             ++counts[hashcodes[j] % i];
2654
2655           /* For the weight function we need some information about the
2656              pagesize on the target.  This is information need not be 100%
2657              accurate.  Since this information is not available (so far) we
2658              define it here to a reasonable default value.  If it is crucial
2659              to have a better value some day simply define this value.  */
2660 # ifndef BFD_TARGET_PAGESIZE
2661 #  define BFD_TARGET_PAGESIZE   (4096)
2662 # endif
2663
2664           /* We in any case need 2 + NSYMS entries for the size values and
2665              the chains.  */
2666           max = (2 + nsyms) * (ARCH_SIZE / 8);
2667
2668 # if 1
2669           /* Variant 1: optimize for short chains.  We add the squares
2670              of all the chain lengths (which favous many small chain
2671              over a few long chains).  */
2672           for (j = 0; j < i; ++j)
2673             max += counts[j] * counts[j];
2674
2675           /* This adds penalties for the overall size of the table.  */
2676           fact = i / (BFD_TARGET_PAGESIZE / (ARCH_SIZE / 8)) + 1;
2677           max *= fact * fact;
2678 # else
2679           /* Variant 2: Optimize a lot more for small table.  Here we
2680              also add squares of the size but we also add penalties for
2681              empty slots (the +1 term).  */
2682           for (j = 0; j < i; ++j)
2683             max += (1 + counts[j]) * (1 + counts[j]);
2684
2685           /* The overall size of the table is considered, but not as
2686              strong as in variant 1, where it is squared.  */
2687           fact = i / (BFD_TARGET_PAGESIZE / (ARCH_SIZE / 8)) + 1;
2688           max *= fact;
2689 # endif
2690
2691           /* Compare with current best results.  */
2692           if (max < best_chlen)
2693             {
2694               best_chlen = max;
2695               best_size = i;
2696             }
2697         }
2698
2699       free (counts);
2700     }
2701   else
2702 #endif /* defined (BFD_HOST_U_64_BIT) */
2703     {
2704       /* This is the fallback solution if no 64bit type is available or if we
2705          are not supposed to spend much time on optimizations.  We select the
2706          bucket count using a fixed set of numbers.  */
2707       for (i = 0; elf_buckets[i] != 0; i++)
2708         {
2709           best_size = elf_buckets[i];
2710           if (dynsymcount < elf_buckets[i + 1])
2711             break;
2712         }
2713     }
2714
2715   /* Free the arrays we needed.  */
2716   free (hashcodes);
2717
2718   return best_size;
2719 }
2720
2721 /* Set up the sizes and contents of the ELF dynamic sections.  This is
2722    called by the ELF linker emulation before_allocation routine.  We
2723    must set the sizes of the sections before the linker sets the
2724    addresses of the various sections.  */
2725
2726 boolean
2727 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
2728                                      export_dynamic, filter_shlib,
2729                                      auxiliary_filters, info, sinterpptr,
2730                                      verdefs)
2731      bfd *output_bfd;
2732      const char *soname;
2733      const char *rpath;
2734      boolean export_dynamic;
2735      const char *filter_shlib;
2736      const char * const *auxiliary_filters;
2737      struct bfd_link_info *info;
2738      asection **sinterpptr;
2739      struct bfd_elf_version_tree *verdefs;
2740 {
2741   bfd_size_type soname_indx;
2742   bfd *dynobj;
2743   struct elf_backend_data *bed;
2744   struct elf_assign_sym_version_info asvinfo;
2745
2746   *sinterpptr = NULL;
2747
2748   soname_indx = (bfd_size_type) -1;
2749
2750   if (info->hash->creator->flavour != bfd_target_elf_flavour)
2751     return true;
2752
2753   /* The backend may have to create some sections regardless of whether
2754      we're dynamic or not.  */
2755   bed = get_elf_backend_data (output_bfd);
2756   if (bed->elf_backend_always_size_sections
2757       && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
2758     return false;
2759
2760   dynobj = elf_hash_table (info)->dynobj;
2761
2762   /* If there were no dynamic objects in the link, there is nothing to
2763      do here.  */
2764   if (dynobj == NULL)
2765     return true;
2766
2767   /* If we are supposed to export all symbols into the dynamic symbol
2768      table (this is not the normal case), then do so.  */
2769   if (export_dynamic)
2770     {
2771       struct elf_info_failed eif;
2772
2773       eif.failed = false;
2774       eif.info = info;
2775       elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
2776                               (PTR) &eif);
2777       if (eif.failed)
2778         return false;
2779     }
2780
2781   if (elf_hash_table (info)->dynamic_sections_created)
2782     {
2783       struct elf_info_failed eif;
2784       struct elf_link_hash_entry *h;
2785       bfd_size_type strsize;
2786
2787       *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
2788       BFD_ASSERT (*sinterpptr != NULL || info->shared);
2789
2790       if (soname != NULL)
2791         {
2792           soname_indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2793                                             soname, true, true);
2794           if (soname_indx == (bfd_size_type) -1
2795               || ! elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
2796             return false;
2797         }
2798
2799       if (info->symbolic)
2800         {
2801           if (! elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
2802             return false;
2803         }
2804
2805       if (rpath != NULL)
2806         {
2807           bfd_size_type indx;
2808
2809           indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
2810                                      true, true);
2811           if (indx == (bfd_size_type) -1
2812               || ! elf_add_dynamic_entry (info, DT_RPATH, indx))
2813             return false;
2814         }
2815
2816       if (filter_shlib != NULL)
2817         {
2818           bfd_size_type indx;
2819
2820           indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2821                                      filter_shlib, true, true);
2822           if (indx == (bfd_size_type) -1
2823               || ! elf_add_dynamic_entry (info, DT_FILTER, indx))
2824             return false;
2825         }
2826
2827       if (auxiliary_filters != NULL)
2828         {
2829           const char * const *p;
2830
2831           for (p = auxiliary_filters; *p != NULL; p++)
2832             {
2833               bfd_size_type indx;
2834
2835               indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2836                                          *p, true, true);
2837               if (indx == (bfd_size_type) -1
2838                   || ! elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
2839                 return false;
2840             }
2841         }
2842
2843       /* Attach all the symbols to their version information.  */
2844       asvinfo.output_bfd = output_bfd;
2845       asvinfo.info = info;
2846       asvinfo.verdefs = verdefs;
2847       asvinfo.export_dynamic = export_dynamic;
2848       asvinfo.failed = false;
2849
2850       elf_link_hash_traverse (elf_hash_table (info),
2851                               elf_link_assign_sym_version,
2852                               (PTR) &asvinfo);
2853       if (asvinfo.failed)
2854         return false;
2855
2856       /* Find all symbols which were defined in a dynamic object and make
2857          the backend pick a reasonable value for them.  */
2858       eif.failed = false;
2859       eif.info = info;
2860       elf_link_hash_traverse (elf_hash_table (info),
2861                               elf_adjust_dynamic_symbol,
2862                               (PTR) &eif);
2863       if (eif.failed)
2864         return false;
2865
2866       /* Add some entries to the .dynamic section.  We fill in some of the
2867          values later, in elf_bfd_final_link, but we must add the entries
2868          now so that we know the final size of the .dynamic section.  */
2869
2870       /* If there are initialization and/or finalization functions to
2871          call then add the corresponding DT_INIT/DT_FINI entries.  */
2872       h = (info->init_function
2873            ? elf_link_hash_lookup (elf_hash_table (info),
2874                                    info->init_function, false,
2875                                    false, false)
2876            : NULL);
2877       if (h != NULL
2878           && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
2879                                         | ELF_LINK_HASH_DEF_REGULAR)) != 0)
2880         {
2881           if (! elf_add_dynamic_entry (info, DT_INIT, 0))
2882             return false;
2883         }
2884       h = (info->fini_function
2885            ? elf_link_hash_lookup (elf_hash_table (info),
2886                                    info->fini_function, false,
2887                                    false, false)
2888            : NULL);
2889       if (h != NULL
2890           && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
2891                                         | ELF_LINK_HASH_DEF_REGULAR)) != 0)
2892         {
2893           if (! elf_add_dynamic_entry (info, DT_FINI, 0))
2894             return false;
2895         }
2896
2897       strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
2898       if (! elf_add_dynamic_entry (info, DT_HASH, 0)
2899           || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
2900           || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
2901           || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
2902           || ! elf_add_dynamic_entry (info, DT_SYMENT,
2903                                       sizeof (Elf_External_Sym)))
2904         return false;
2905     }
2906
2907   /* The backend must work out the sizes of all the other dynamic
2908      sections.  */
2909   if (bed->elf_backend_size_dynamic_sections
2910       && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
2911     return false;
2912
2913   if (elf_hash_table (info)->dynamic_sections_created)
2914     {
2915       size_t dynsymcount;
2916       asection *s;
2917       size_t bucketcount = 0;
2918       Elf_Internal_Sym isym;
2919       size_t hash_entry_size;
2920
2921       /* Set up the version definition section.  */
2922       s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
2923       BFD_ASSERT (s != NULL);
2924
2925       /* We may have created additional version definitions if we are
2926          just linking a regular application.  */
2927       verdefs = asvinfo.verdefs;
2928
2929       if (verdefs == NULL)
2930         _bfd_strip_section_from_output (s);
2931       else
2932         {
2933           unsigned int cdefs;
2934           bfd_size_type size;
2935           struct bfd_elf_version_tree *t;
2936           bfd_byte *p;
2937           Elf_Internal_Verdef def;
2938           Elf_Internal_Verdaux defaux;
2939
2940           cdefs = 0;
2941           size = 0;
2942
2943           /* Make space for the base version.  */
2944           size += sizeof (Elf_External_Verdef);
2945           size += sizeof (Elf_External_Verdaux);
2946           ++cdefs;
2947
2948           for (t = verdefs; t != NULL; t = t->next)
2949             {
2950               struct bfd_elf_version_deps *n;
2951
2952               size += sizeof (Elf_External_Verdef);
2953               size += sizeof (Elf_External_Verdaux);
2954               ++cdefs;
2955
2956               for (n = t->deps; n != NULL; n = n->next)
2957                 size += sizeof (Elf_External_Verdaux);
2958             }
2959
2960           s->_raw_size = size;
2961           s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
2962           if (s->contents == NULL && s->_raw_size != 0)
2963             return false;
2964
2965           /* Fill in the version definition section.  */
2966
2967           p = s->contents;
2968
2969           def.vd_version = VER_DEF_CURRENT;
2970           def.vd_flags = VER_FLG_BASE;
2971           def.vd_ndx = 1;
2972           def.vd_cnt = 1;
2973           def.vd_aux = sizeof (Elf_External_Verdef);
2974           def.vd_next = (sizeof (Elf_External_Verdef)
2975                          + sizeof (Elf_External_Verdaux));
2976
2977           if (soname_indx != (bfd_size_type) -1)
2978             {
2979               def.vd_hash = bfd_elf_hash (soname);
2980               defaux.vda_name = soname_indx;
2981             }
2982           else
2983             {
2984               const char *name;
2985               bfd_size_type indx;
2986
2987               name = output_bfd->filename;
2988               def.vd_hash = bfd_elf_hash (name);
2989               indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
2990                                             name, true, false);
2991               if (indx == (bfd_size_type) -1)
2992                 return false;
2993               defaux.vda_name = indx;
2994             }
2995           defaux.vda_next = 0;
2996
2997           _bfd_elf_swap_verdef_out (output_bfd, &def,
2998                                     (Elf_External_Verdef *)p);
2999           p += sizeof (Elf_External_Verdef);
3000           _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
3001                                      (Elf_External_Verdaux *) p);
3002           p += sizeof (Elf_External_Verdaux);
3003
3004           for (t = verdefs; t != NULL; t = t->next)
3005             {
3006               unsigned int cdeps;
3007               struct bfd_elf_version_deps *n;
3008               struct elf_link_hash_entry *h;
3009
3010               cdeps = 0;
3011               for (n = t->deps; n != NULL; n = n->next)
3012                 ++cdeps;
3013
3014               /* Add a symbol representing this version.  */
3015               h = NULL;
3016               if (! (_bfd_generic_link_add_one_symbol
3017                      (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
3018                       (bfd_vma) 0, (const char *) NULL, false,
3019                       get_elf_backend_data (dynobj)->collect,
3020                       (struct bfd_link_hash_entry **) &h)))
3021                 return false;
3022               h->elf_link_hash_flags &= ~ ELF_LINK_NON_ELF;
3023               h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3024               h->type = STT_OBJECT;
3025               h->verinfo.vertree = t;
3026
3027               if (! _bfd_elf_link_record_dynamic_symbol (info, h))
3028                 return false;
3029
3030               def.vd_version = VER_DEF_CURRENT;
3031               def.vd_flags = 0;
3032               if (t->globals == NULL && t->locals == NULL && ! t->used)
3033                 def.vd_flags |= VER_FLG_WEAK;
3034               def.vd_ndx = t->vernum + 1;
3035               def.vd_cnt = cdeps + 1;
3036               def.vd_hash = bfd_elf_hash (t->name);
3037               def.vd_aux = sizeof (Elf_External_Verdef);
3038               if (t->next != NULL)
3039                 def.vd_next = (sizeof (Elf_External_Verdef)
3040                                + (cdeps + 1) * sizeof (Elf_External_Verdaux));
3041               else
3042                 def.vd_next = 0;
3043
3044               _bfd_elf_swap_verdef_out (output_bfd, &def,
3045                                         (Elf_External_Verdef *) p);
3046               p += sizeof (Elf_External_Verdef);
3047
3048               defaux.vda_name = h->dynstr_index;
3049               if (t->deps == NULL)
3050                 defaux.vda_next = 0;
3051               else
3052                 defaux.vda_next = sizeof (Elf_External_Verdaux);
3053               t->name_indx = defaux.vda_name;
3054
3055               _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
3056                                          (Elf_External_Verdaux *) p);
3057               p += sizeof (Elf_External_Verdaux);
3058
3059               for (n = t->deps; n != NULL; n = n->next)
3060                 {
3061                   if (n->version_needed == NULL)
3062                     {
3063                       /* This can happen if there was an error in the
3064                          version script.  */
3065                       defaux.vda_name = 0;
3066                     }
3067                   else
3068                     defaux.vda_name = n->version_needed->name_indx;
3069                   if (n->next == NULL)
3070                     defaux.vda_next = 0;
3071                   else
3072                     defaux.vda_next = sizeof (Elf_External_Verdaux);
3073
3074                   _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
3075                                              (Elf_External_Verdaux *) p);
3076                   p += sizeof (Elf_External_Verdaux);
3077                 }
3078             }
3079
3080           if (! elf_add_dynamic_entry (info, DT_VERDEF, 0)
3081               || ! elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
3082             return false;
3083
3084           elf_tdata (output_bfd)->cverdefs = cdefs;
3085         }
3086
3087       /* Work out the size of the version reference section.  */
3088
3089       s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3090       BFD_ASSERT (s != NULL);
3091       {
3092         struct elf_find_verdep_info sinfo;
3093
3094         sinfo.output_bfd = output_bfd;
3095         sinfo.info = info;
3096         sinfo.vers = elf_tdata (output_bfd)->cverdefs;
3097         if (sinfo.vers == 0)
3098           sinfo.vers = 1;
3099         sinfo.failed = false;
3100
3101         elf_link_hash_traverse (elf_hash_table (info),
3102                                 elf_link_find_version_dependencies,
3103                                 (PTR) &sinfo);
3104
3105         if (elf_tdata (output_bfd)->verref == NULL)
3106           _bfd_strip_section_from_output (s);
3107         else
3108           {
3109             Elf_Internal_Verneed *t;
3110             unsigned int size;
3111             unsigned int crefs;
3112             bfd_byte *p;
3113
3114             /* Build the version definition section.  */
3115             size = 0;
3116             crefs = 0;
3117             for (t = elf_tdata (output_bfd)->verref;
3118                  t != NULL;
3119                  t = t->vn_nextref)
3120               {
3121                 Elf_Internal_Vernaux *a;
3122
3123                 size += sizeof (Elf_External_Verneed);
3124                 ++crefs;
3125                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3126                   size += sizeof (Elf_External_Vernaux);
3127               }
3128
3129             s->_raw_size = size;
3130             s->contents = (bfd_byte *) bfd_alloc (output_bfd, size);
3131             if (s->contents == NULL)
3132               return false;
3133
3134             p = s->contents;
3135             for (t = elf_tdata (output_bfd)->verref;
3136                  t != NULL;
3137                  t = t->vn_nextref)
3138               {
3139                 unsigned int caux;
3140                 Elf_Internal_Vernaux *a;
3141                 bfd_size_type indx;
3142
3143                 caux = 0;
3144                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3145                   ++caux;
3146
3147                 t->vn_version = VER_NEED_CURRENT;
3148                 t->vn_cnt = caux;
3149                 if (elf_dt_name (t->vn_bfd) != NULL)
3150                   indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
3151                                              elf_dt_name (t->vn_bfd),
3152                                              true, false);
3153                 else
3154                   indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
3155                                              t->vn_bfd->filename, true, false);
3156                 if (indx == (bfd_size_type) -1)
3157                   return false;
3158                 t->vn_file = indx;
3159                 t->vn_aux = sizeof (Elf_External_Verneed);
3160                 if (t->vn_nextref == NULL)
3161                   t->vn_next = 0;
3162                 else
3163                   t->vn_next = (sizeof (Elf_External_Verneed)
3164                                 + caux * sizeof (Elf_External_Vernaux));
3165
3166                 _bfd_elf_swap_verneed_out (output_bfd, t,
3167                                            (Elf_External_Verneed *) p);
3168                 p += sizeof (Elf_External_Verneed);
3169
3170                 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3171                   {
3172                     a->vna_hash = bfd_elf_hash (a->vna_nodename);
3173                     indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr,
3174                                                a->vna_nodename, true, false);
3175                     if (indx == (bfd_size_type) -1)
3176                       return false;
3177                     a->vna_name = indx;
3178                     if (a->vna_nextptr == NULL)
3179                       a->vna_next = 0;
3180                     else
3181                       a->vna_next = sizeof (Elf_External_Vernaux);
3182
3183                     _bfd_elf_swap_vernaux_out (output_bfd, a,
3184                                                (Elf_External_Vernaux *) p);
3185                     p += sizeof (Elf_External_Vernaux);
3186                   }
3187               }
3188
3189             if (! elf_add_dynamic_entry (info, DT_VERNEED, 0)
3190                 || ! elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
3191               return false;
3192
3193             elf_tdata (output_bfd)->cverrefs = crefs;
3194           }
3195       }
3196
3197       /* Assign dynsym indicies.  In a shared library we generate a
3198          section symbol for each output section, which come first.
3199          Next come all of the back-end allocated local dynamic syms,
3200          followed by the rest of the global symbols.  */
3201
3202       dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info);
3203
3204       /* Work out the size of the symbol version section.  */
3205       s = bfd_get_section_by_name (dynobj, ".gnu.version");
3206       BFD_ASSERT (s != NULL);
3207       if (dynsymcount == 0
3208           || (verdefs == NULL && elf_tdata (output_bfd)->verref == NULL))
3209         {
3210           _bfd_strip_section_from_output (s);
3211           /* The DYNSYMCOUNT might have changed if we were going to
3212              output a dynamic symbol table entry for S.  */
3213           dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info);
3214         }
3215       else
3216         {
3217           s->_raw_size = dynsymcount * sizeof (Elf_External_Versym);
3218           s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
3219           if (s->contents == NULL)
3220             return false;
3221
3222           if (! elf_add_dynamic_entry (info, DT_VERSYM, 0))
3223             return false;
3224         }
3225
3226       /* Set the size of the .dynsym and .hash sections.  We counted
3227          the number of dynamic symbols in elf_link_add_object_symbols.
3228          We will build the contents of .dynsym and .hash when we build
3229          the final symbol table, because until then we do not know the
3230          correct value to give the symbols.  We built the .dynstr
3231          section as we went along in elf_link_add_object_symbols.  */
3232       s = bfd_get_section_by_name (dynobj, ".dynsym");
3233       BFD_ASSERT (s != NULL);
3234       s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
3235       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
3236       if (s->contents == NULL && s->_raw_size != 0)
3237         return false;
3238
3239       /* The first entry in .dynsym is a dummy symbol.  */
3240       isym.st_value = 0;
3241       isym.st_size = 0;
3242       isym.st_name = 0;
3243       isym.st_info = 0;
3244       isym.st_other = 0;
3245       isym.st_shndx = 0;
3246       elf_swap_symbol_out (output_bfd, &isym,
3247                            (PTR) (Elf_External_Sym *) s->contents);
3248
3249       /* Compute the size of the hashing table.  As a side effect this
3250          computes the hash values for all the names we export.  */
3251       bucketcount = compute_bucket_count (info);
3252
3253       s = bfd_get_section_by_name (dynobj, ".hash");
3254       BFD_ASSERT (s != NULL);
3255       hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
3256       s->_raw_size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
3257       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
3258       if (s->contents == NULL)
3259         return false;
3260       memset (s->contents, 0, (size_t) s->_raw_size);
3261
3262       bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
3263       bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
3264                s->contents + hash_entry_size);
3265
3266       elf_hash_table (info)->bucketcount = bucketcount;
3267
3268       s = bfd_get_section_by_name (dynobj, ".dynstr");
3269       BFD_ASSERT (s != NULL);
3270       s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
3271
3272       if (! elf_add_dynamic_entry (info, DT_NULL, 0))
3273         return false;
3274     }
3275
3276   return true;
3277 }
3278 \f
3279 /* Fix up the flags for a symbol.  This handles various cases which
3280    can only be fixed after all the input files are seen.  This is
3281    currently called by both adjust_dynamic_symbol and
3282    assign_sym_version, which is unnecessary but perhaps more robust in
3283    the face of future changes.  */
3284
3285 static boolean
3286 elf_fix_symbol_flags (h, eif)
3287      struct elf_link_hash_entry *h;
3288      struct elf_info_failed *eif;
3289 {
3290   /* If this symbol was mentioned in a non-ELF file, try to set
3291      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
3292      permit a non-ELF file to correctly refer to a symbol defined in
3293      an ELF dynamic object.  */
3294   if ((h->elf_link_hash_flags & ELF_LINK_NON_ELF) != 0)
3295     {
3296       if (h->root.type != bfd_link_hash_defined
3297           && h->root.type != bfd_link_hash_defweak)
3298         h->elf_link_hash_flags |= (ELF_LINK_HASH_REF_REGULAR
3299                                    | ELF_LINK_HASH_REF_REGULAR_NONWEAK);
3300       else
3301         {
3302           if (h->root.u.def.section->owner != NULL
3303               && (bfd_get_flavour (h->root.u.def.section->owner)
3304                   == bfd_target_elf_flavour))
3305             h->elf_link_hash_flags |= (ELF_LINK_HASH_REF_REGULAR
3306                                        | ELF_LINK_HASH_REF_REGULAR_NONWEAK);
3307           else
3308             h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3309         }
3310
3311       if (h->dynindx == -1
3312           && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3313               || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0))
3314         {
3315           if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
3316             {
3317               eif->failed = true;
3318               return false;
3319             }
3320         }
3321     }
3322   else
3323     {
3324       /* Unfortunately, ELF_LINK_NON_ELF is only correct if the symbol
3325          was first seen in a non-ELF file.  Fortunately, if the symbol
3326          was first seen in an ELF file, we're probably OK unless the
3327          symbol was defined in a non-ELF file.  Catch that case here.
3328          FIXME: We're still in trouble if the symbol was first seen in
3329          a dynamic object, and then later in a non-ELF regular object.  */
3330       if ((h->root.type == bfd_link_hash_defined
3331            || h->root.type == bfd_link_hash_defweak)
3332           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
3333           && (h->root.u.def.section->owner != NULL
3334               ? (bfd_get_flavour (h->root.u.def.section->owner)
3335                  != bfd_target_elf_flavour)
3336               : (bfd_is_abs_section (h->root.u.def.section)
3337                  && (h->elf_link_hash_flags
3338                      & ELF_LINK_HASH_DEF_DYNAMIC) == 0)))
3339         h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3340     }
3341
3342   /* If this is a final link, and the symbol was defined as a common
3343      symbol in a regular object file, and there was no definition in
3344      any dynamic object, then the linker will have allocated space for
3345      the symbol in a common section but the ELF_LINK_HASH_DEF_REGULAR
3346      flag will not have been set.  */
3347   if (h->root.type == bfd_link_hash_defined
3348       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
3349       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) != 0
3350       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3351       && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
3352     h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3353
3354   /* If -Bsymbolic was used (which means to bind references to global
3355      symbols to the definition within the shared object), and this
3356      symbol was defined in a regular object, then it actually doesn't
3357      need a PLT entry.  */
3358   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
3359       && eif->info->shared
3360       && eif->info->symbolic
3361       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
3362     {
3363       h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
3364       h->plt.offset = (bfd_vma) -1;
3365     }
3366
3367   /* If this is a weak defined symbol in a dynamic object, and we know
3368      the real definition in the dynamic object, copy interesting flags
3369      over to the real definition.  */
3370   if (h->weakdef != NULL)
3371     {
3372       struct elf_link_hash_entry *weakdef;
3373
3374       BFD_ASSERT (h->root.type == bfd_link_hash_defined
3375                   || h->root.type == bfd_link_hash_defweak);
3376       weakdef = h->weakdef;
3377       BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
3378                   || weakdef->root.type == bfd_link_hash_defweak);
3379       BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
3380
3381       /* If the real definition is defined by a regular object file,
3382          don't do anything special.  See the longer description in
3383          elf_adjust_dynamic_symbol, below.  */
3384       if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
3385         h->weakdef = NULL;
3386       else
3387         weakdef->elf_link_hash_flags |=
3388           (h->elf_link_hash_flags
3389            & (ELF_LINK_HASH_REF_REGULAR
3390               | ELF_LINK_HASH_REF_REGULAR_NONWEAK
3391               | ELF_LINK_NON_GOT_REF));
3392     }
3393
3394   return true;
3395 }
3396
3397 /* Make the backend pick a good value for a dynamic symbol.  This is
3398    called via elf_link_hash_traverse, and also calls itself
3399    recursively.  */
3400
3401 static boolean
3402 elf_adjust_dynamic_symbol (h, data)
3403      struct elf_link_hash_entry *h;
3404      PTR data;
3405 {
3406   struct elf_info_failed *eif = (struct elf_info_failed *) data;
3407   bfd *dynobj;
3408   struct elf_backend_data *bed;
3409
3410   /* Ignore indirect symbols.  These are added by the versioning code.  */
3411   if (h->root.type == bfd_link_hash_indirect)
3412     return true;
3413
3414   /* Fix the symbol flags.  */
3415   if (! elf_fix_symbol_flags (h, eif))
3416     return false;
3417
3418   /* If this symbol does not require a PLT entry, and it is not
3419      defined by a dynamic object, or is not referenced by a regular
3420      object, ignore it.  We do have to handle a weak defined symbol,
3421      even if no regular object refers to it, if we decided to add it
3422      to the dynamic symbol table.  FIXME: Do we normally need to worry
3423      about symbols which are defined by one dynamic object and
3424      referenced by another one?  */
3425   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
3426       && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
3427           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3428           || ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
3429               && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
3430     {
3431       h->plt.offset = (bfd_vma) -1;
3432       return true;
3433     }
3434
3435   /* If we've already adjusted this symbol, don't do it again.  This
3436      can happen via a recursive call.  */
3437   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
3438     return true;
3439
3440   /* Don't look at this symbol again.  Note that we must set this
3441      after checking the above conditions, because we may look at a
3442      symbol once, decide not to do anything, and then get called
3443      recursively later after REF_REGULAR is set below.  */
3444   h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
3445
3446   /* If this is a weak definition, and we know a real definition, and
3447      the real symbol is not itself defined by a regular object file,
3448      then get a good value for the real definition.  We handle the
3449      real symbol first, for the convenience of the backend routine.
3450
3451      Note that there is a confusing case here.  If the real definition
3452      is defined by a regular object file, we don't get the real symbol
3453      from the dynamic object, but we do get the weak symbol.  If the
3454      processor backend uses a COPY reloc, then if some routine in the
3455      dynamic object changes the real symbol, we will not see that
3456      change in the corresponding weak symbol.  This is the way other
3457      ELF linkers work as well, and seems to be a result of the shared
3458      library model.
3459
3460      I will clarify this issue.  Most SVR4 shared libraries define the
3461      variable _timezone and define timezone as a weak synonym.  The
3462      tzset call changes _timezone.  If you write
3463        extern int timezone;
3464        int _timezone = 5;
3465        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
3466      you might expect that, since timezone is a synonym for _timezone,
3467      the same number will print both times.  However, if the processor
3468      backend uses a COPY reloc, then actually timezone will be copied
3469      into your process image, and, since you define _timezone
3470      yourself, _timezone will not.  Thus timezone and _timezone will
3471      wind up at different memory locations.  The tzset call will set
3472      _timezone, leaving timezone unchanged.  */
3473
3474   if (h->weakdef != NULL)
3475     {
3476       /* If we get to this point, we know there is an implicit
3477          reference by a regular object file via the weak symbol H.
3478          FIXME: Is this really true?  What if the traversal finds
3479          H->WEAKDEF before it finds H?  */
3480       h->weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
3481
3482       if (! elf_adjust_dynamic_symbol (h->weakdef, (PTR) eif))
3483         return false;
3484     }
3485
3486   /* If a symbol has no type and no size and does not require a PLT
3487      entry, then we are probably about to do the wrong thing here: we
3488      are probably going to create a COPY reloc for an empty object.
3489      This case can arise when a shared object is built with assembly
3490      code, and the assembly code fails to set the symbol type.  */
3491   if (h->size == 0
3492       && h->type == STT_NOTYPE
3493       && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
3494     (*_bfd_error_handler)
3495       (_("warning: type and size of dynamic symbol `%s' are not defined"),
3496          h->root.root.string);
3497
3498   dynobj = elf_hash_table (eif->info)->dynobj;
3499   bed = get_elf_backend_data (dynobj);
3500   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
3501     {
3502       eif->failed = true;
3503       return false;
3504     }
3505
3506   return true;
3507 }
3508 \f
3509 /* This routine is used to export all defined symbols into the dynamic
3510    symbol table.  It is called via elf_link_hash_traverse.  */
3511
3512 static boolean
3513 elf_export_symbol (h, data)
3514      struct elf_link_hash_entry *h;
3515      PTR data;
3516 {
3517   struct elf_info_failed *eif = (struct elf_info_failed *) data;
3518
3519   /* Ignore indirect symbols.  These are added by the versioning code.  */
3520   if (h->root.type == bfd_link_hash_indirect)
3521     return true;
3522
3523   if (h->dynindx == -1
3524       && (h->elf_link_hash_flags
3525           & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
3526     {
3527       if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
3528         {
3529           eif->failed = true;
3530           return false;
3531         }
3532     }
3533
3534   return true;
3535 }
3536 \f
3537 /* Look through the symbols which are defined in other shared
3538    libraries and referenced here.  Update the list of version
3539    dependencies.  This will be put into the .gnu.version_r section.
3540    This function is called via elf_link_hash_traverse.  */
3541
3542 static boolean
3543 elf_link_find_version_dependencies (h, data)
3544      struct elf_link_hash_entry *h;
3545      PTR data;
3546 {
3547   struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
3548   Elf_Internal_Verneed *t;
3549   Elf_Internal_Vernaux *a;
3550
3551   /* We only care about symbols defined in shared objects with version
3552      information.  */
3553   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3554       || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
3555       || h->dynindx == -1
3556       || h->verinfo.verdef == NULL)
3557     return true;
3558
3559   /* See if we already know about this version.  */
3560   for (t = elf_tdata (rinfo->output_bfd)->verref; t != NULL; t = t->vn_nextref)
3561     {
3562       if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
3563         continue;
3564
3565       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
3566         if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
3567           return true;
3568
3569       break;
3570     }
3571
3572   /* This is a new version.  Add it to tree we are building.  */
3573
3574   if (t == NULL)
3575     {
3576       t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->output_bfd, sizeof *t);
3577       if (t == NULL)
3578         {
3579           rinfo->failed = true;
3580           return false;
3581         }
3582
3583       t->vn_bfd = h->verinfo.verdef->vd_bfd;
3584       t->vn_nextref = elf_tdata (rinfo->output_bfd)->verref;
3585       elf_tdata (rinfo->output_bfd)->verref = t;
3586     }
3587
3588   a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->output_bfd, sizeof *a);
3589
3590   /* Note that we are copying a string pointer here, and testing it
3591      above.  If bfd_elf_string_from_elf_section is ever changed to
3592      discard the string data when low in memory, this will have to be
3593      fixed.  */
3594   a->vna_nodename = h->verinfo.verdef->vd_nodename;
3595
3596   a->vna_flags = h->verinfo.verdef->vd_flags;
3597   a->vna_nextptr = t->vn_auxptr;
3598
3599   h->verinfo.verdef->vd_exp_refno = rinfo->vers;
3600   ++rinfo->vers;
3601
3602   a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
3603
3604   t->vn_auxptr = a;
3605
3606   return true;
3607 }
3608
3609 /* Figure out appropriate versions for all the symbols.  We may not
3610    have the version number script until we have read all of the input
3611    files, so until that point we don't know which symbols should be
3612    local.  This function is called via elf_link_hash_traverse.  */
3613
3614 static boolean
3615 elf_link_assign_sym_version (h, data)
3616      struct elf_link_hash_entry *h;
3617      PTR data;
3618 {
3619   struct elf_assign_sym_version_info *sinfo =
3620     (struct elf_assign_sym_version_info *) data;
3621   struct bfd_link_info *info = sinfo->info;
3622   struct elf_info_failed eif;
3623   char *p;
3624
3625   /* Fix the symbol flags.  */
3626   eif.failed = false;
3627   eif.info = info;
3628   if (! elf_fix_symbol_flags (h, &eif))
3629     {
3630       if (eif.failed)
3631         sinfo->failed = true;
3632       return false;
3633     }
3634
3635   /* We only need version numbers for symbols defined in regular
3636      objects.  */
3637   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3638     return true;
3639
3640   p = strchr (h->root.root.string, ELF_VER_CHR);
3641   if (p != NULL && h->verinfo.vertree == NULL)
3642     {
3643       struct bfd_elf_version_tree *t;
3644       boolean hidden;
3645
3646       hidden = true;
3647
3648       /* There are two consecutive ELF_VER_CHR characters if this is
3649          not a hidden symbol.  */
3650       ++p;
3651       if (*p == ELF_VER_CHR)
3652         {
3653           hidden = false;
3654           ++p;
3655         }
3656
3657       /* If there is no version string, we can just return out.  */
3658       if (*p == '\0')
3659         {
3660           if (hidden)
3661             h->elf_link_hash_flags |= ELF_LINK_HIDDEN;
3662           return true;
3663         }
3664
3665       /* Look for the version.  If we find it, it is no longer weak.  */
3666       for (t = sinfo->verdefs; t != NULL; t = t->next)
3667         {
3668           if (strcmp (t->name, p) == 0)
3669             {
3670               int len;
3671               char *alc;
3672               struct bfd_elf_version_expr *d;
3673
3674               len = p - h->root.root.string;
3675               alc = bfd_alloc (sinfo->output_bfd, len);
3676               if (alc == NULL)
3677                 return false;
3678               strncpy (alc, h->root.root.string, len - 1);
3679               alc[len - 1] = '\0';
3680               if (alc[len - 2] == ELF_VER_CHR)
3681                 alc[len - 2] = '\0';
3682
3683               h->verinfo.vertree = t;
3684               t->used = true;
3685               d = NULL;
3686
3687               if (t->globals != NULL)
3688                 {
3689                   for (d = t->globals; d != NULL; d = d->next)
3690                     if ((*d->match) (d, alc))
3691                       break;
3692                 }
3693
3694               /* See if there is anything to force this symbol to
3695                  local scope.  */
3696               if (d == NULL && t->locals != NULL)
3697                 {
3698                   for (d = t->locals; d != NULL; d = d->next)
3699                     {
3700                       if ((*d->match) (d, alc))
3701                         {
3702                           if (h->dynindx != -1
3703                               && info->shared
3704                               && ! sinfo->export_dynamic)
3705                             {
3706                               h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
3707                               h->elf_link_hash_flags &=~
3708                                 ELF_LINK_HASH_NEEDS_PLT;
3709                               h->dynindx = -1;
3710                               h->plt.offset = (bfd_vma) -1;
3711                               /* FIXME: The name of the symbol has
3712                                  already been recorded in the dynamic
3713                                  string table section.  */
3714                             }
3715
3716                           break;
3717                         }
3718                     }
3719                 }
3720
3721               bfd_release (sinfo->output_bfd, alc);
3722               break;
3723             }
3724         }
3725
3726       /* If we are building an application, we need to create a
3727          version node for this version.  */
3728       if (t == NULL && ! info->shared)
3729         {
3730           struct bfd_elf_version_tree **pp;
3731           int version_index;
3732
3733           /* If we aren't going to export this symbol, we don't need
3734              to worry about it. */
3735           if (h->dynindx == -1)
3736             return true;
3737
3738           t = ((struct bfd_elf_version_tree *)
3739                bfd_alloc (sinfo->output_bfd, sizeof *t));
3740           if (t == NULL)
3741             {
3742               sinfo->failed = true;
3743               return false;
3744             }
3745
3746           t->next = NULL;
3747           t->name = p;
3748           t->globals = NULL;
3749           t->locals = NULL;
3750           t->deps = NULL;
3751           t->name_indx = (unsigned int) -1;
3752           t->used = true;
3753
3754           version_index = 1;
3755           for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next)
3756             ++version_index;
3757           t->vernum = version_index;
3758
3759           *pp = t;
3760
3761           h->verinfo.vertree = t;
3762         }
3763       else if (t == NULL)
3764         {
3765           /* We could not find the version for a symbol when
3766              generating a shared archive.  Return an error.  */
3767           (*_bfd_error_handler)
3768             (_("%s: undefined versioned symbol name %s"),
3769              bfd_get_filename (sinfo->output_bfd), h->root.root.string);
3770           bfd_set_error (bfd_error_bad_value);
3771           sinfo->failed = true;
3772           return false;
3773         }
3774
3775       if (hidden)
3776         h->elf_link_hash_flags |= ELF_LINK_HIDDEN;
3777     }
3778
3779   /* If we don't have a version for this symbol, see if we can find
3780      something.  */
3781   if (h->verinfo.vertree == NULL && sinfo->verdefs != NULL)
3782     {
3783       struct bfd_elf_version_tree *t;
3784       struct bfd_elf_version_tree *deflt;
3785       struct bfd_elf_version_expr *d;
3786
3787       /* See if can find what version this symbol is in.  If the
3788          symbol is supposed to be local, then don't actually register
3789          it.  */
3790       deflt = NULL;
3791       for (t = sinfo->verdefs; t != NULL; t = t->next)
3792         {
3793           if (t->globals != NULL)
3794             {
3795               for (d = t->globals; d != NULL; d = d->next)
3796                 {
3797                   if ((*d->match) (d, h->root.root.string))
3798                     {
3799                       h->verinfo.vertree = t;
3800                       break;
3801                     }
3802                 }
3803
3804               if (d != NULL)
3805                 break;
3806             }
3807
3808           if (t->locals != NULL)
3809             {
3810               for (d = t->locals; d != NULL; d = d->next)
3811                 {
3812                   if (d->pattern[0] == '*' && d->pattern[1] == '\0')
3813                     deflt = t;
3814                   else if ((*d->match) (d, h->root.root.string))
3815                     {
3816                       h->verinfo.vertree = t;
3817                       if (h->dynindx != -1
3818                           && info->shared
3819                           && ! sinfo->export_dynamic)
3820                         {
3821                           h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
3822                           h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
3823                           h->dynindx = -1;
3824                           h->plt.offset = (bfd_vma) -1;
3825                           /* FIXME: The name of the symbol has already
3826                              been recorded in the dynamic string table
3827                              section.  */
3828                         }
3829                       break;
3830                     }
3831                 }
3832
3833               if (d != NULL)
3834                 break;
3835             }
3836         }
3837
3838       if (deflt != NULL && h->verinfo.vertree == NULL)
3839         {
3840           h->verinfo.vertree = deflt;
3841           if (h->dynindx != -1
3842               && info->shared
3843               && ! sinfo->export_dynamic)
3844             {
3845               h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
3846               h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
3847               h->dynindx = -1;
3848               h->plt.offset = (bfd_vma) -1;
3849               /* FIXME: The name of the symbol has already been
3850                  recorded in the dynamic string table section.  */
3851             }
3852         }
3853     }
3854
3855   return true;
3856 }
3857 \f
3858 /* Final phase of ELF linker.  */
3859
3860 /* A structure we use to avoid passing large numbers of arguments.  */
3861
3862 struct elf_final_link_info
3863 {
3864   /* General link information.  */
3865   struct bfd_link_info *info;
3866   /* Output BFD.  */
3867   bfd *output_bfd;
3868   /* Symbol string table.  */
3869   struct bfd_strtab_hash *symstrtab;
3870   /* .dynsym section.  */
3871   asection *dynsym_sec;
3872   /* .hash section.  */
3873   asection *hash_sec;
3874   /* symbol version section (.gnu.version).  */
3875   asection *symver_sec;
3876   /* Buffer large enough to hold contents of any section.  */
3877   bfd_byte *contents;
3878   /* Buffer large enough to hold external relocs of any section.  */
3879   PTR external_relocs;
3880   /* Buffer large enough to hold internal relocs of any section.  */
3881   Elf_Internal_Rela *internal_relocs;
3882   /* Buffer large enough to hold external local symbols of any input
3883      BFD.  */
3884   Elf_External_Sym *external_syms;
3885   /* Buffer large enough to hold internal local symbols of any input
3886      BFD.  */
3887   Elf_Internal_Sym *internal_syms;
3888   /* Array large enough to hold a symbol index for each local symbol
3889      of any input BFD.  */
3890   long *indices;
3891   /* Array large enough to hold a section pointer for each local
3892      symbol of any input BFD.  */
3893   asection **sections;
3894   /* Buffer to hold swapped out symbols.  */
3895   Elf_External_Sym *symbuf;
3896   /* Number of swapped out symbols in buffer.  */
3897   size_t symbuf_count;
3898   /* Number of symbols which fit in symbuf.  */
3899   size_t symbuf_size;
3900 };
3901
3902 static boolean elf_link_output_sym
3903   PARAMS ((struct elf_final_link_info *, const char *,
3904            Elf_Internal_Sym *, asection *));
3905 static boolean elf_link_flush_output_syms
3906   PARAMS ((struct elf_final_link_info *));
3907 static boolean elf_link_output_extsym
3908   PARAMS ((struct elf_link_hash_entry *, PTR));
3909 static boolean elf_link_input_bfd
3910   PARAMS ((struct elf_final_link_info *, bfd *));
3911 static boolean elf_reloc_link_order
3912   PARAMS ((bfd *, struct bfd_link_info *, asection *,
3913            struct bfd_link_order *));
3914
3915 /* This struct is used to pass information to elf_link_output_extsym.  */
3916
3917 struct elf_outext_info
3918 {
3919   boolean failed;
3920   boolean localsyms;
3921   struct elf_final_link_info *finfo;
3922 };
3923
3924 /* Compute the size of, and allocate space for, REL_HDR which is the
3925    section header for a section containing relocations for O.  */
3926
3927 static boolean
3928 elf_link_size_reloc_section (abfd, rel_hdr, o)
3929      bfd *abfd;
3930      Elf_Internal_Shdr *rel_hdr;
3931      asection *o;
3932 {
3933   register struct elf_link_hash_entry **p, **pend;
3934   unsigned reloc_count;
3935
3936   /* Figure out how many relocations there will be.  */
3937   if (rel_hdr == &elf_section_data (o)->rel_hdr)
3938     reloc_count = elf_section_data (o)->rel_count;
3939   else
3940     reloc_count = elf_section_data (o)->rel_count2;
3941
3942   /* That allows us to calculate the size of the section.  */
3943   rel_hdr->sh_size = rel_hdr->sh_entsize * reloc_count;
3944
3945   /* The contents field must last into write_object_contents, so we
3946      allocate it with bfd_alloc rather than malloc.  */
3947   rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
3948   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
3949     return false;
3950
3951   /* We only allocate one set of hash entries, so we only do it the
3952      first time we are called.  */
3953   if (elf_section_data (o)->rel_hashes == NULL)
3954     {
3955       p = ((struct elf_link_hash_entry **)
3956            bfd_malloc (o->reloc_count
3957                        * sizeof (struct elf_link_hash_entry *)));
3958       if (p == NULL && o->reloc_count != 0)
3959         return false;
3960
3961       elf_section_data (o)->rel_hashes = p;
3962       pend = p + o->reloc_count;
3963       for (; p < pend; p++)
3964         *p = NULL;
3965     }
3966
3967   return true;
3968 }
3969
3970 /* When performing a relocateable link, the input relocations are
3971    preserved.  But, if they reference global symbols, the indices
3972    referenced must be updated.  Update all the relocations in
3973    REL_HDR (there are COUNT of them), using the data in REL_HASH.  */
3974
3975 static void
3976 elf_link_adjust_relocs (abfd, rel_hdr, count, rel_hash)
3977      bfd *abfd;
3978      Elf_Internal_Shdr *rel_hdr;
3979      unsigned int count;
3980      struct elf_link_hash_entry **rel_hash;
3981 {
3982   unsigned int i;
3983
3984   for (i = 0; i < count; i++, rel_hash++)
3985     {
3986       if (*rel_hash == NULL)
3987         continue;
3988
3989       BFD_ASSERT ((*rel_hash)->indx >= 0);
3990
3991       if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
3992         {
3993           Elf_External_Rel *erel;
3994           Elf_Internal_Rel irel;
3995
3996           erel = (Elf_External_Rel *) rel_hdr->contents + i;
3997           elf_swap_reloc_in (abfd, erel, &irel);
3998           irel.r_info = ELF_R_INFO ((*rel_hash)->indx,
3999                                     ELF_R_TYPE (irel.r_info));
4000           elf_swap_reloc_out (abfd, &irel, erel);
4001         }
4002       else
4003         {
4004           Elf_External_Rela *erela;
4005           Elf_Internal_Rela irela;
4006
4007           BFD_ASSERT (rel_hdr->sh_entsize
4008                       == sizeof (Elf_External_Rela));
4009
4010           erela = (Elf_External_Rela *) rel_hdr->contents + i;
4011           elf_swap_reloca_in (abfd, erela, &irela);
4012           irela.r_info = ELF_R_INFO ((*rel_hash)->indx,
4013                                      ELF_R_TYPE (irela.r_info));
4014           elf_swap_reloca_out (abfd, &irela, erela);
4015         }
4016     }
4017 }
4018
4019 /* Do the final step of an ELF link.  */
4020
4021 boolean
4022 elf_bfd_final_link (abfd, info)
4023      bfd *abfd;
4024      struct bfd_link_info *info;
4025 {
4026   boolean dynamic;
4027   bfd *dynobj;
4028   struct elf_final_link_info finfo;
4029   register asection *o;
4030   register struct bfd_link_order *p;
4031   register bfd *sub;
4032   size_t max_contents_size;
4033   size_t max_external_reloc_size;
4034   size_t max_internal_reloc_count;
4035   size_t max_sym_count;
4036   file_ptr off;
4037   Elf_Internal_Sym elfsym;
4038   unsigned int i;
4039   Elf_Internal_Shdr *symtab_hdr;
4040   Elf_Internal_Shdr *symstrtab_hdr;
4041   struct elf_backend_data *bed = get_elf_backend_data (abfd);
4042   struct elf_outext_info eoinfo;
4043
4044   if (info->shared)
4045     abfd->flags |= DYNAMIC;
4046
4047   dynamic = elf_hash_table (info)->dynamic_sections_created;
4048   dynobj = elf_hash_table (info)->dynobj;
4049
4050   finfo.info = info;
4051   finfo.output_bfd = abfd;
4052   finfo.symstrtab = elf_stringtab_init ();
4053   if (finfo.symstrtab == NULL)
4054     return false;
4055
4056   if (! dynamic)
4057     {
4058       finfo.dynsym_sec = NULL;
4059       finfo.hash_sec = NULL;
4060       finfo.symver_sec = NULL;
4061     }
4062   else
4063     {
4064       finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
4065       finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
4066       BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
4067       finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
4068       /* Note that it is OK if symver_sec is NULL.  */
4069     }
4070
4071   finfo.contents = NULL;
4072   finfo.external_relocs = NULL;
4073   finfo.internal_relocs = NULL;
4074   finfo.external_syms = NULL;
4075   finfo.internal_syms = NULL;
4076   finfo.indices = NULL;
4077   finfo.sections = NULL;
4078   finfo.symbuf = NULL;
4079   finfo.symbuf_count = 0;
4080
4081   /* Count up the number of relocations we will output for each output
4082      section, so that we know the sizes of the reloc sections.  We
4083      also figure out some maximum sizes.  */
4084   max_contents_size = 0;
4085   max_external_reloc_size = 0;
4086   max_internal_reloc_count = 0;
4087   max_sym_count = 0;
4088   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4089     {
4090       o->reloc_count = 0;
4091
4092       for (p = o->link_order_head; p != NULL; p = p->next)
4093         {
4094           if (p->type == bfd_section_reloc_link_order
4095               || p->type == bfd_symbol_reloc_link_order)
4096             ++o->reloc_count;
4097           else if (p->type == bfd_indirect_link_order)
4098             {
4099               asection *sec;
4100
4101               sec = p->u.indirect.section;
4102
4103               /* Mark all sections which are to be included in the
4104                  link.  This will normally be every section.  We need
4105                  to do this so that we can identify any sections which
4106                  the linker has decided to not include.  */
4107               sec->linker_mark = true;
4108
4109               if (info->relocateable)
4110                 o->reloc_count += sec->reloc_count;
4111
4112               if (sec->_raw_size > max_contents_size)
4113                 max_contents_size = sec->_raw_size;
4114               if (sec->_cooked_size > max_contents_size)
4115                 max_contents_size = sec->_cooked_size;
4116
4117               /* We are interested in just local symbols, not all
4118                  symbols.  */
4119               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
4120                   && (sec->owner->flags & DYNAMIC) == 0)
4121                 {
4122                   size_t sym_count;
4123
4124                   if (elf_bad_symtab (sec->owner))
4125                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
4126                                  / sizeof (Elf_External_Sym));
4127                   else
4128                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
4129
4130                   if (sym_count > max_sym_count)
4131                     max_sym_count = sym_count;
4132
4133                   if ((sec->flags & SEC_RELOC) != 0)
4134                     {
4135                       size_t ext_size;
4136
4137                       ext_size = elf_section_data (sec)->rel_hdr.sh_size;
4138                       if (ext_size > max_external_reloc_size)
4139                         max_external_reloc_size = ext_size;
4140                       if (sec->reloc_count > max_internal_reloc_count)
4141                         max_internal_reloc_count = sec->reloc_count;
4142                     }
4143                 }
4144             }
4145         }
4146
4147       if (o->reloc_count > 0)
4148         o->flags |= SEC_RELOC;
4149       else
4150         {
4151           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
4152              set it (this is probably a bug) and if it is set
4153              assign_section_numbers will create a reloc section.  */
4154           o->flags &=~ SEC_RELOC;
4155         }
4156
4157       /* If the SEC_ALLOC flag is not set, force the section VMA to
4158          zero.  This is done in elf_fake_sections as well, but forcing
4159          the VMA to 0 here will ensure that relocs against these
4160          sections are handled correctly.  */
4161       if ((o->flags & SEC_ALLOC) == 0
4162           && ! o->user_set_vma)
4163         o->vma = 0;
4164     }
4165
4166   /* Figure out the file positions for everything but the symbol table
4167      and the relocs.  We set symcount to force assign_section_numbers
4168      to create a symbol table.  */
4169   bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
4170   BFD_ASSERT (! abfd->output_has_begun);
4171   if (! _bfd_elf_compute_section_file_positions (abfd, info))
4172     goto error_return;
4173
4174   /* Figure out how many relocations we will have in each section.
4175      Just using RELOC_COUNT isn't good enough since that doesn't
4176      maintain a separate value for REL vs. RELA relocations.  */
4177   if (info->relocateable)
4178     for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
4179       for (o = sub->sections; o != NULL; o = o->next)
4180         {
4181           asection *output_section;
4182
4183           if (! o->linker_mark)
4184             {
4185               /* This section was omitted from the link.  */
4186               continue;
4187             }
4188
4189           output_section = o->output_section;
4190
4191           if (output_section != NULL
4192               && (o->flags & SEC_RELOC) != 0)
4193             {
4194               struct bfd_elf_section_data *esdi
4195                 = elf_section_data (o);
4196               struct bfd_elf_section_data *esdo
4197                 = elf_section_data (output_section);
4198               unsigned int *rel_count;
4199               unsigned int *rel_count2;
4200
4201               /* We must be careful to add the relocation froms the
4202                  input section to the right output count.  */
4203               if (esdi->rel_hdr.sh_entsize == esdo->rel_hdr.sh_entsize)
4204                 {
4205                   rel_count = &esdo->rel_count;
4206                   rel_count2 = &esdo->rel_count2;
4207                 }
4208               else
4209                 {
4210                   rel_count = &esdo->rel_count2;
4211                   rel_count2 = &esdo->rel_count;
4212                 }
4213
4214               *rel_count += (esdi->rel_hdr.sh_size
4215                              / esdi->rel_hdr.sh_entsize);
4216               if (esdi->rel_hdr2)
4217                 *rel_count2 += (esdi->rel_hdr2->sh_size
4218                                 / esdi->rel_hdr2->sh_entsize);
4219             }
4220         }
4221
4222   /* That created the reloc sections.  Set their sizes, and assign
4223      them file positions, and allocate some buffers.  */
4224   for (o = abfd->sections; o != NULL; o = o->next)
4225     {
4226       if ((o->flags & SEC_RELOC) != 0)
4227         {
4228           if (!elf_link_size_reloc_section (abfd,
4229                                             &elf_section_data (o)->rel_hdr,
4230                                             o))
4231             goto error_return;
4232
4233           if (elf_section_data (o)->rel_hdr2
4234               && !elf_link_size_reloc_section (abfd,
4235                                                elf_section_data (o)->rel_hdr2,
4236                                                o))
4237             goto error_return;
4238         }
4239
4240       /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
4241          to count upwards while actually outputting the relocations. */
4242       elf_section_data (o)->rel_count = 0;
4243       elf_section_data (o)->rel_count2 = 0;
4244     }
4245
4246   _bfd_elf_assign_file_positions_for_relocs (abfd);
4247
4248   /* We have now assigned file positions for all the sections except
4249      .symtab and .strtab.  We start the .symtab section at the current
4250      file position, and write directly to it.  We build the .strtab
4251      section in memory.  */
4252   bfd_get_symcount (abfd) = 0;
4253   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4254   /* sh_name is set in prep_headers.  */
4255   symtab_hdr->sh_type = SHT_SYMTAB;
4256   symtab_hdr->sh_flags = 0;
4257   symtab_hdr->sh_addr = 0;
4258   symtab_hdr->sh_size = 0;
4259   symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
4260   /* sh_link is set in assign_section_numbers.  */
4261   /* sh_info is set below.  */
4262   /* sh_offset is set just below.  */
4263   symtab_hdr->sh_addralign = 4;  /* FIXME: system dependent?  */
4264
4265   off = elf_tdata (abfd)->next_file_pos;
4266   off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
4267
4268   /* Note that at this point elf_tdata (abfd)->next_file_pos is
4269      incorrect.  We do not yet know the size of the .symtab section.
4270      We correct next_file_pos below, after we do know the size.  */
4271
4272   /* Allocate a buffer to hold swapped out symbols.  This is to avoid
4273      continuously seeking to the right position in the file.  */
4274   if (! info->keep_memory || max_sym_count < 20)
4275     finfo.symbuf_size = 20;
4276   else
4277     finfo.symbuf_size = max_sym_count;
4278   finfo.symbuf = ((Elf_External_Sym *)
4279                   bfd_malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
4280   if (finfo.symbuf == NULL)
4281     goto error_return;
4282
4283   /* Start writing out the symbol table.  The first symbol is always a
4284      dummy symbol.  */
4285   if (info->strip != strip_all || info->relocateable)
4286     {
4287       elfsym.st_value = 0;
4288       elfsym.st_size = 0;
4289       elfsym.st_info = 0;
4290       elfsym.st_other = 0;
4291       elfsym.st_shndx = SHN_UNDEF;
4292       if (! elf_link_output_sym (&finfo, (const char *) NULL,
4293                                  &elfsym, bfd_und_section_ptr))
4294         goto error_return;
4295     }
4296
4297 #if 0
4298   /* Some standard ELF linkers do this, but we don't because it causes
4299      bootstrap comparison failures.  */
4300   /* Output a file symbol for the output file as the second symbol.
4301      We output this even if we are discarding local symbols, although
4302      I'm not sure if this is correct.  */
4303   elfsym.st_value = 0;
4304   elfsym.st_size = 0;
4305   elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
4306   elfsym.st_other = 0;
4307   elfsym.st_shndx = SHN_ABS;
4308   if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
4309                              &elfsym, bfd_abs_section_ptr))
4310     goto error_return;
4311 #endif
4312
4313   /* Output a symbol for each section.  We output these even if we are
4314      discarding local symbols, since they are used for relocs.  These
4315      symbols have no names.  We store the index of each one in the
4316      index field of the section, so that we can find it again when
4317      outputting relocs.  */
4318   if (info->strip != strip_all || info->relocateable)
4319     {
4320       elfsym.st_size = 0;
4321       elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
4322       elfsym.st_other = 0;
4323       for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
4324         {
4325           o = section_from_elf_index (abfd, i);
4326           if (o != NULL)
4327             o->target_index = bfd_get_symcount (abfd);
4328           elfsym.st_shndx = i;
4329           if (info->relocateable || o == NULL)
4330             elfsym.st_value = 0;
4331           else
4332             elfsym.st_value = o->vma;
4333           if (! elf_link_output_sym (&finfo, (const char *) NULL,
4334                                      &elfsym, o))
4335             goto error_return;
4336         }
4337     }
4338
4339   /* Allocate some memory to hold information read in from the input
4340      files.  */
4341   finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
4342   finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
4343   finfo.internal_relocs = ((Elf_Internal_Rela *)
4344                            bfd_malloc (max_internal_reloc_count
4345                                        * sizeof (Elf_Internal_Rela)
4346                                        * bed->s->int_rels_per_ext_rel));
4347   finfo.external_syms = ((Elf_External_Sym *)
4348                          bfd_malloc (max_sym_count
4349                                      * sizeof (Elf_External_Sym)));
4350   finfo.internal_syms = ((Elf_Internal_Sym *)
4351                          bfd_malloc (max_sym_count
4352                                      * sizeof (Elf_Internal_Sym)));
4353   finfo.indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
4354   finfo.sections = ((asection **)
4355                     bfd_malloc (max_sym_count * sizeof (asection *)));
4356   if ((finfo.contents == NULL && max_contents_size != 0)
4357       || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
4358       || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
4359       || (finfo.external_syms == NULL && max_sym_count != 0)
4360       || (finfo.internal_syms == NULL && max_sym_count != 0)
4361       || (finfo.indices == NULL && max_sym_count != 0)
4362       || (finfo.sections == NULL && max_sym_count != 0))
4363     goto error_return;
4364
4365   /* Since ELF permits relocations to be against local symbols, we
4366      must have the local symbols available when we do the relocations.
4367      Since we would rather only read the local symbols once, and we
4368      would rather not keep them in memory, we handle all the
4369      relocations for a single input file at the same time.
4370
4371      Unfortunately, there is no way to know the total number of local
4372      symbols until we have seen all of them, and the local symbol
4373      indices precede the global symbol indices.  This means that when
4374      we are generating relocateable output, and we see a reloc against
4375      a global symbol, we can not know the symbol index until we have
4376      finished examining all the local symbols to see which ones we are
4377      going to output.  To deal with this, we keep the relocations in
4378      memory, and don't output them until the end of the link.  This is
4379      an unfortunate waste of memory, but I don't see a good way around
4380      it.  Fortunately, it only happens when performing a relocateable
4381      link, which is not the common case.  FIXME: If keep_memory is set
4382      we could write the relocs out and then read them again; I don't
4383      know how bad the memory loss will be.  */
4384
4385   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
4386     sub->output_has_begun = false;
4387   for (o = abfd->sections; o != NULL; o = o->next)
4388     {
4389       for (p = o->link_order_head; p != NULL; p = p->next)
4390         {
4391           if (p->type == bfd_indirect_link_order
4392               && (bfd_get_flavour (p->u.indirect.section->owner)
4393                   == bfd_target_elf_flavour))
4394             {
4395               sub = p->u.indirect.section->owner;
4396               if (! sub->output_has_begun)
4397                 {
4398                   if (! elf_link_input_bfd (&finfo, sub))
4399                     goto error_return;
4400                   sub->output_has_begun = true;
4401                 }
4402             }
4403           else if (p->type == bfd_section_reloc_link_order
4404                    || p->type == bfd_symbol_reloc_link_order)
4405             {
4406               if (! elf_reloc_link_order (abfd, info, o, p))
4407                 goto error_return;
4408             }
4409           else
4410             {
4411               if (! _bfd_default_link_order (abfd, info, o, p))
4412                 goto error_return;
4413             }
4414         }
4415     }
4416
4417   /* That wrote out all the local symbols.  Finish up the symbol table
4418      with the global symbols.  */
4419
4420   if (info->strip != strip_all && info->shared)
4421     {
4422       /* Output any global symbols that got converted to local in a
4423          version script.  We do this in a separate step since ELF
4424          requires all local symbols to appear prior to any global
4425          symbols.  FIXME: We should only do this if some global
4426          symbols were, in fact, converted to become local.  FIXME:
4427          Will this work correctly with the Irix 5 linker?  */
4428       eoinfo.failed = false;
4429       eoinfo.finfo = &finfo;
4430       eoinfo.localsyms = true;
4431       elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
4432                               (PTR) &eoinfo);
4433       if (eoinfo.failed)
4434         return false;
4435     }
4436
4437   /* The sh_info field records the index of the first non local symbol.  */
4438   symtab_hdr->sh_info = bfd_get_symcount (abfd);
4439
4440   if (dynamic)
4441     {
4442       Elf_Internal_Sym sym;
4443       Elf_External_Sym *dynsym =
4444         (Elf_External_Sym *)finfo.dynsym_sec->contents;
4445       long last_local = 0;
4446
4447       /* Write out the section symbols for the output sections.  */
4448       if (info->shared)
4449         {
4450           asection *s;
4451
4452           sym.st_size = 0;
4453           sym.st_name = 0;
4454           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
4455           sym.st_other = 0;
4456
4457           for (s = abfd->sections; s != NULL; s = s->next)
4458             {
4459               int indx;
4460               indx = elf_section_data (s)->this_idx;
4461               BFD_ASSERT (indx > 0);
4462               sym.st_shndx = indx;
4463               sym.st_value = s->vma;
4464
4465               elf_swap_symbol_out (abfd, &sym,
4466                                    dynsym + elf_section_data (s)->dynindx);
4467             }
4468
4469           last_local = bfd_count_sections (abfd);
4470         }
4471
4472       /* Write out the local dynsyms.  */
4473       if (elf_hash_table (info)->dynlocal)
4474         {
4475           struct elf_link_local_dynamic_entry *e;
4476           for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
4477             {
4478               asection *s;
4479
4480               sym.st_size = e->isym.st_size;
4481               sym.st_other = e->isym.st_other;
4482
4483               /* Copy the internal symbol as is.
4484                  Note that we saved a word of storage and overwrote
4485                  the original st_name with the dynstr_index.  */
4486               sym = e->isym;
4487
4488               if (e->isym.st_shndx > 0 && e->isym.st_shndx < SHN_LORESERVE)
4489                 {
4490                   s = bfd_section_from_elf_index (e->input_bfd,
4491                                                   e->isym.st_shndx);
4492
4493                   sym.st_shndx =
4494                     elf_section_data (s->output_section)->this_idx;
4495                   sym.st_value = (s->output_section->vma
4496                                   + s->output_offset
4497                                   + e->isym.st_value);
4498                 }
4499
4500               if (last_local < e->dynindx)
4501                 last_local = e->dynindx;
4502
4503               elf_swap_symbol_out (abfd, &sym, dynsym + e->dynindx);
4504             }
4505         }
4506
4507       elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info =
4508         last_local + 1;
4509     }
4510
4511   /* We get the global symbols from the hash table.  */
4512   eoinfo.failed = false;
4513   eoinfo.localsyms = false;
4514   eoinfo.finfo = &finfo;
4515   elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
4516                           (PTR) &eoinfo);
4517   if (eoinfo.failed)
4518     return false;
4519
4520   /* If backend needs to output some symbols not present in the hash
4521      table, do it now.  */
4522   if (bed->elf_backend_output_arch_syms)
4523     {
4524       if (! (*bed->elf_backend_output_arch_syms)
4525               (abfd, info, (PTR) &finfo,
4526                (boolean (*) PARAMS ((PTR, const char *,
4527                             Elf_Internal_Sym *, asection *)))
4528                elf_link_output_sym))
4529         return false;
4530     }
4531
4532   /* Flush all symbols to the file.  */
4533   if (! elf_link_flush_output_syms (&finfo))
4534     return false;
4535
4536   /* Now we know the size of the symtab section.  */
4537   off += symtab_hdr->sh_size;
4538
4539   /* Finish up and write out the symbol string table (.strtab)
4540      section.  */
4541   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
4542   /* sh_name was set in prep_headers.  */
4543   symstrtab_hdr->sh_type = SHT_STRTAB;
4544   symstrtab_hdr->sh_flags = 0;
4545   symstrtab_hdr->sh_addr = 0;
4546   symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
4547   symstrtab_hdr->sh_entsize = 0;
4548   symstrtab_hdr->sh_link = 0;
4549   symstrtab_hdr->sh_info = 0;
4550   /* sh_offset is set just below.  */
4551   symstrtab_hdr->sh_addralign = 1;
4552
4553   off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
4554   elf_tdata (abfd)->next_file_pos = off;
4555
4556   if (bfd_get_symcount (abfd) > 0)
4557     {
4558       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
4559           || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
4560         return false;
4561     }
4562
4563   /* Adjust the relocs to have the correct symbol indices.  */
4564   for (o = abfd->sections; o != NULL; o = o->next)
4565     {
4566       if ((o->flags & SEC_RELOC) == 0)
4567         continue;
4568
4569       elf_link_adjust_relocs (abfd, &elf_section_data (o)->rel_hdr,
4570                               elf_section_data (o)->rel_count,
4571                               elf_section_data (o)->rel_hashes);
4572       if (elf_section_data (o)->rel_hdr2 != NULL)
4573         elf_link_adjust_relocs (abfd, elf_section_data (o)->rel_hdr2,
4574                                 elf_section_data (o)->rel_count2,
4575                                 (elf_section_data (o)->rel_hashes
4576                                  + elf_section_data (o)->rel_count));
4577
4578       /* Set the reloc_count field to 0 to prevent write_relocs from
4579          trying to swap the relocs out itself.  */
4580       o->reloc_count = 0;
4581     }
4582
4583   /* If we are linking against a dynamic object, or generating a
4584      shared library, finish up the dynamic linking information.  */
4585   if (dynamic)
4586     {
4587       Elf_External_Dyn *dyncon, *dynconend;
4588
4589       /* Fix up .dynamic entries.  */
4590       o = bfd_get_section_by_name (dynobj, ".dynamic");
4591       BFD_ASSERT (o != NULL);
4592
4593       dyncon = (Elf_External_Dyn *) o->contents;
4594       dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
4595       for (; dyncon < dynconend; dyncon++)
4596         {
4597           Elf_Internal_Dyn dyn;
4598           const char *name;
4599           unsigned int type;
4600
4601           elf_swap_dyn_in (dynobj, dyncon, &dyn);
4602
4603           switch (dyn.d_tag)
4604             {
4605             default:
4606               break;
4607             case DT_INIT:
4608               name = info->init_function;
4609               goto get_sym;
4610             case DT_FINI:
4611               name = info->fini_function;
4612             get_sym:
4613               {
4614                 struct elf_link_hash_entry *h;
4615
4616                 h = elf_link_hash_lookup (elf_hash_table (info), name,
4617                                           false, false, true);
4618                 if (h != NULL
4619                     && (h->root.type == bfd_link_hash_defined
4620                         || h->root.type == bfd_link_hash_defweak))
4621                   {
4622                     dyn.d_un.d_val = h->root.u.def.value;
4623                     o = h->root.u.def.section;
4624                     if (o->output_section != NULL)
4625                       dyn.d_un.d_val += (o->output_section->vma
4626                                          + o->output_offset);
4627                     else
4628                       {
4629                         /* The symbol is imported from another shared
4630                            library and does not apply to this one.  */
4631                         dyn.d_un.d_val = 0;
4632                       }
4633
4634                     elf_swap_dyn_out (dynobj, &dyn, dyncon);
4635                   }
4636               }
4637               break;
4638
4639             case DT_HASH:
4640               name = ".hash";
4641               goto get_vma;
4642             case DT_STRTAB:
4643               name = ".dynstr";
4644               goto get_vma;
4645             case DT_SYMTAB:
4646               name = ".dynsym";
4647               goto get_vma;
4648             case DT_VERDEF:
4649               name = ".gnu.version_d";
4650               goto get_vma;
4651             case DT_VERNEED:
4652               name = ".gnu.version_r";
4653               goto get_vma;
4654             case DT_VERSYM:
4655               name = ".gnu.version";
4656             get_vma:
4657               o = bfd_get_section_by_name (abfd, name);
4658               BFD_ASSERT (o != NULL);
4659               dyn.d_un.d_ptr = o->vma;
4660               elf_swap_dyn_out (dynobj, &dyn, dyncon);
4661               break;
4662
4663             case DT_REL:
4664             case DT_RELA:
4665             case DT_RELSZ:
4666             case DT_RELASZ:
4667               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
4668                 type = SHT_REL;
4669               else
4670                 type = SHT_RELA;
4671               dyn.d_un.d_val = 0;
4672               for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
4673                 {
4674                   Elf_Internal_Shdr *hdr;
4675
4676                   hdr = elf_elfsections (abfd)[i];
4677                   if (hdr->sh_type == type
4678                       && (hdr->sh_flags & SHF_ALLOC) != 0)
4679                     {
4680                       if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
4681                         dyn.d_un.d_val += hdr->sh_size;
4682                       else
4683                         {
4684                           if (dyn.d_un.d_val == 0
4685                               || hdr->sh_addr < dyn.d_un.d_val)
4686                             dyn.d_un.d_val = hdr->sh_addr;
4687                         }
4688                     }
4689                 }
4690               elf_swap_dyn_out (dynobj, &dyn, dyncon);
4691               break;
4692             }
4693         }
4694     }
4695
4696   /* If we have created any dynamic sections, then output them.  */
4697   if (dynobj != NULL)
4698     {
4699       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
4700         goto error_return;
4701
4702       for (o = dynobj->sections; o != NULL; o = o->next)
4703         {
4704           if ((o->flags & SEC_HAS_CONTENTS) == 0
4705               || o->_raw_size == 0)
4706             continue;
4707           if ((o->flags & SEC_LINKER_CREATED) == 0)
4708             {
4709               /* At this point, we are only interested in sections
4710                  created by elf_link_create_dynamic_sections.  */
4711               continue;
4712             }
4713           if ((elf_section_data (o->output_section)->this_hdr.sh_type
4714                != SHT_STRTAB)
4715               || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
4716             {
4717               if (! bfd_set_section_contents (abfd, o->output_section,
4718                                               o->contents, o->output_offset,
4719                                               o->_raw_size))
4720                 goto error_return;
4721             }
4722           else
4723             {
4724               file_ptr off;
4725
4726               /* The contents of the .dynstr section are actually in a
4727                  stringtab.  */
4728               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
4729               if (bfd_seek (abfd, off, SEEK_SET) != 0
4730                   || ! _bfd_stringtab_emit (abfd,
4731                                             elf_hash_table (info)->dynstr))
4732                 goto error_return;
4733             }
4734         }
4735     }
4736
4737   /* If we have optimized stabs strings, output them.  */
4738   if (elf_hash_table (info)->stab_info != NULL)
4739     {
4740       if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
4741         goto error_return;
4742     }
4743
4744   if (finfo.symstrtab != NULL)
4745     _bfd_stringtab_free (finfo.symstrtab);
4746   if (finfo.contents != NULL)
4747     free (finfo.contents);
4748   if (finfo.external_relocs != NULL)
4749     free (finfo.external_relocs);
4750   if (finfo.internal_relocs != NULL)
4751     free (finfo.internal_relocs);
4752   if (finfo.external_syms != NULL)
4753     free (finfo.external_syms);
4754   if (finfo.internal_syms != NULL)
4755     free (finfo.internal_syms);
4756   if (finfo.indices != NULL)
4757     free (finfo.indices);
4758   if (finfo.sections != NULL)
4759     free (finfo.sections);
4760   if (finfo.symbuf != NULL)
4761     free (finfo.symbuf);
4762   for (o = abfd->sections; o != NULL; o = o->next)
4763     {
4764       if ((o->flags & SEC_RELOC) != 0
4765           && elf_section_data (o)->rel_hashes != NULL)
4766         free (elf_section_data (o)->rel_hashes);
4767     }
4768
4769   elf_tdata (abfd)->linker = true;
4770
4771   return true;
4772
4773  error_return:
4774   if (finfo.symstrtab != NULL)
4775     _bfd_stringtab_free (finfo.symstrtab);
4776   if (finfo.contents != NULL)
4777     free (finfo.contents);
4778   if (finfo.external_relocs != NULL)
4779     free (finfo.external_relocs);
4780   if (finfo.internal_relocs != NULL)
4781     free (finfo.internal_relocs);
4782   if (finfo.external_syms != NULL)
4783     free (finfo.external_syms);
4784   if (finfo.internal_syms != NULL)
4785     free (finfo.internal_syms);
4786   if (finfo.indices != NULL)
4787     free (finfo.indices);
4788   if (finfo.sections != NULL)
4789     free (finfo.sections);
4790   if (finfo.symbuf != NULL)
4791     free (finfo.symbuf);
4792   for (o = abfd->sections; o != NULL; o = o->next)
4793     {
4794       if ((o->flags & SEC_RELOC) != 0
4795           && elf_section_data (o)->rel_hashes != NULL)
4796         free (elf_section_data (o)->rel_hashes);
4797     }
4798
4799   return false;
4800 }
4801
4802 /* Add a symbol to the output symbol table.  */
4803
4804 static boolean
4805 elf_link_output_sym (finfo, name, elfsym, input_sec)
4806      struct elf_final_link_info *finfo;
4807      const char *name;
4808      Elf_Internal_Sym *elfsym;
4809      asection *input_sec;
4810 {
4811   boolean (*output_symbol_hook) PARAMS ((bfd *,
4812                                          struct bfd_link_info *info,
4813                                          const char *,
4814                                          Elf_Internal_Sym *,
4815                                          asection *));
4816
4817   output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
4818     elf_backend_link_output_symbol_hook;
4819   if (output_symbol_hook != NULL)
4820     {
4821       if (! ((*output_symbol_hook)
4822              (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
4823         return false;
4824     }
4825
4826   if (name == (const char *) NULL || *name == '\0')
4827     elfsym->st_name = 0;
4828   else if (input_sec->flags & SEC_EXCLUDE)
4829     elfsym->st_name = 0;
4830   else
4831     {
4832       elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
4833                                                             name, true,
4834                                                             false);
4835       if (elfsym->st_name == (unsigned long) -1)
4836         return false;
4837     }
4838
4839   if (finfo->symbuf_count >= finfo->symbuf_size)
4840     {
4841       if (! elf_link_flush_output_syms (finfo))
4842         return false;
4843     }
4844
4845   elf_swap_symbol_out (finfo->output_bfd, elfsym,
4846                        (PTR) (finfo->symbuf + finfo->symbuf_count));
4847   ++finfo->symbuf_count;
4848
4849   ++ bfd_get_symcount (finfo->output_bfd);
4850
4851   return true;
4852 }
4853
4854 /* Flush the output symbols to the file.  */
4855
4856 static boolean
4857 elf_link_flush_output_syms (finfo)
4858      struct elf_final_link_info *finfo;
4859 {
4860   if (finfo->symbuf_count > 0)
4861     {
4862       Elf_Internal_Shdr *symtab;
4863
4864       symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
4865
4866       if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
4867                     SEEK_SET) != 0
4868           || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
4869                          sizeof (Elf_External_Sym), finfo->output_bfd)
4870               != finfo->symbuf_count * sizeof (Elf_External_Sym)))
4871         return false;
4872
4873       symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
4874
4875       finfo->symbuf_count = 0;
4876     }
4877
4878   return true;
4879 }
4880
4881 /* Add an external symbol to the symbol table.  This is called from
4882    the hash table traversal routine.  When generating a shared object,
4883    we go through the symbol table twice.  The first time we output
4884    anything that might have been forced to local scope in a version
4885    script.  The second time we output the symbols that are still
4886    global symbols.  */
4887
4888 static boolean
4889 elf_link_output_extsym (h, data)
4890      struct elf_link_hash_entry *h;
4891      PTR data;
4892 {
4893   struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
4894   struct elf_final_link_info *finfo = eoinfo->finfo;
4895   boolean strip;
4896   Elf_Internal_Sym sym;
4897   asection *input_sec;
4898
4899   /* Decide whether to output this symbol in this pass.  */
4900   if (eoinfo->localsyms)
4901     {
4902       if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4903         return true;
4904     }
4905   else
4906     {
4907       if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
4908         return true;
4909     }
4910
4911   /* If we are not creating a shared library, and this symbol is
4912      referenced by a shared library but is not defined anywhere, then
4913      warn that it is undefined.  If we do not do this, the runtime
4914      linker will complain that the symbol is undefined when the
4915      program is run.  We don't have to worry about symbols that are
4916      referenced by regular files, because we will already have issued
4917      warnings for them.  */
4918   if (! finfo->info->relocateable
4919       && ! (finfo->info->shared
4920             && !finfo->info->no_undefined)
4921       && h->root.type == bfd_link_hash_undefined
4922       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
4923       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
4924     {
4925       if (! ((*finfo->info->callbacks->undefined_symbol)
4926              (finfo->info, h->root.root.string, h->root.u.undef.abfd,
4927               (asection *) NULL, 0)))
4928         {
4929           eoinfo->failed = true;
4930           return false;
4931         }
4932     }
4933
4934   /* We don't want to output symbols that have never been mentioned by
4935      a regular file, or that we have been told to strip.  However, if
4936      h->indx is set to -2, the symbol is used by a reloc and we must
4937      output it.  */
4938   if (h->indx == -2)
4939     strip = false;
4940   else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4941             || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
4942            && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
4943            && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
4944     strip = true;
4945   else if (finfo->info->strip == strip_all
4946            || (finfo->info->strip == strip_some
4947                && bfd_hash_lookup (finfo->info->keep_hash,
4948                                    h->root.root.string,
4949                                    false, false) == NULL))
4950     strip = true;
4951   else
4952     strip = false;
4953
4954   /* If we're stripping it, and it's not a dynamic symbol, there's
4955      nothing else to do.  */
4956   if (strip && h->dynindx == -1)
4957     return true;
4958
4959   sym.st_value = 0;
4960   sym.st_size = h->size;
4961   sym.st_other = h->other;
4962   if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
4963     sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
4964   else if (h->root.type == bfd_link_hash_undefweak
4965            || h->root.type == bfd_link_hash_defweak)
4966     sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
4967   else
4968     sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
4969
4970   switch (h->root.type)
4971     {
4972     default:
4973     case bfd_link_hash_new:
4974       abort ();
4975       return false;
4976
4977     case bfd_link_hash_undefined:
4978       input_sec = bfd_und_section_ptr;
4979       sym.st_shndx = SHN_UNDEF;
4980       break;
4981
4982     case bfd_link_hash_undefweak:
4983       input_sec = bfd_und_section_ptr;
4984       sym.st_shndx = SHN_UNDEF;
4985       break;
4986
4987     case bfd_link_hash_defined:
4988     case bfd_link_hash_defweak:
4989       {
4990         input_sec = h->root.u.def.section;
4991         if (input_sec->output_section != NULL)
4992           {
4993             sym.st_shndx =
4994               _bfd_elf_section_from_bfd_section (finfo->output_bfd,
4995                                                  input_sec->output_section);
4996             if (sym.st_shndx == (unsigned short) -1)
4997               {
4998                 (*_bfd_error_handler)
4999                   (_("%s: could not find output section %s for input section %s"),
5000                    bfd_get_filename (finfo->output_bfd),
5001                    input_sec->output_section->name,
5002                    input_sec->name);
5003                 eoinfo->failed = true;
5004                 return false;
5005               }
5006
5007             /* ELF symbols in relocateable files are section relative,
5008                but in nonrelocateable files they are virtual
5009                addresses.  */
5010             sym.st_value = h->root.u.def.value + input_sec->output_offset;
5011             if (! finfo->info->relocateable)
5012               sym.st_value += input_sec->output_section->vma;
5013           }
5014         else
5015           {
5016             BFD_ASSERT (input_sec->owner == NULL
5017                         || (input_sec->owner->flags & DYNAMIC) != 0);
5018             sym.st_shndx = SHN_UNDEF;
5019             input_sec = bfd_und_section_ptr;
5020           }
5021       }
5022       break;
5023
5024     case bfd_link_hash_common:
5025       input_sec = h->root.u.c.p->section;
5026       sym.st_shndx = SHN_COMMON;
5027       sym.st_value = 1 << h->root.u.c.p->alignment_power;
5028       break;
5029
5030     case bfd_link_hash_indirect:
5031       /* These symbols are created by symbol versioning.  They point
5032          to the decorated version of the name.  For example, if the
5033          symbol foo@@GNU_1.2 is the default, which should be used when
5034          foo is used with no version, then we add an indirect symbol
5035          foo which points to foo@@GNU_1.2.  We ignore these symbols,
5036          since the indirected symbol is already in the hash table.  If
5037          the indirect symbol is non-ELF, fall through and output it.  */
5038       if ((h->elf_link_hash_flags & ELF_LINK_NON_ELF) == 0)
5039         return true;
5040
5041       /* Fall through.  */
5042     case bfd_link_hash_warning:
5043       /* We can't represent these symbols in ELF, although a warning
5044          symbol may have come from a .gnu.warning.SYMBOL section.  We
5045          just put the target symbol in the hash table.  If the target
5046          symbol does not really exist, don't do anything.  */
5047       if (h->root.u.i.link->type == bfd_link_hash_new)
5048         return true;
5049       return (elf_link_output_extsym
5050               ((struct elf_link_hash_entry *) h->root.u.i.link, data));
5051     }
5052
5053   /* Give the processor backend a chance to tweak the symbol value,
5054      and also to finish up anything that needs to be done for this
5055      symbol.  */
5056   if ((h->dynindx != -1
5057        || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
5058       && elf_hash_table (finfo->info)->dynamic_sections_created)
5059     {
5060       struct elf_backend_data *bed;
5061
5062       bed = get_elf_backend_data (finfo->output_bfd);
5063       if (! ((*bed->elf_backend_finish_dynamic_symbol)
5064              (finfo->output_bfd, finfo->info, h, &sym)))
5065         {
5066           eoinfo->failed = true;
5067           return false;
5068         }
5069     }
5070
5071   /* If we are marking the symbol as undefined, and there are no
5072      non-weak references to this symbol from a regular object, then
5073      mark the symbol as weak undefined; if there are non-weak
5074      references, mark the symbol as strong.  We can't do this earlier,
5075      because it might not be marked as undefined until the
5076      finish_dynamic_symbol routine gets through with it.  */
5077   if (sym.st_shndx == SHN_UNDEF
5078       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) != 0
5079       && (ELF_ST_BIND(sym.st_info) == STB_GLOBAL
5080           || ELF_ST_BIND(sym.st_info) == STB_WEAK))
5081     {
5082       int bindtype;
5083
5084       if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK) != 0)
5085         bindtype = STB_GLOBAL;
5086       else
5087         bindtype = STB_WEAK;
5088       sym.st_info = ELF_ST_INFO (bindtype, ELF_ST_TYPE (sym.st_info));
5089     }
5090
5091   /* If this symbol should be put in the .dynsym section, then put it
5092      there now.  We have already know the symbol index.  We also fill
5093      in the entry in the .hash section.  */
5094   if (h->dynindx != -1
5095       && elf_hash_table (finfo->info)->dynamic_sections_created)
5096     {
5097       size_t bucketcount;
5098       size_t bucket;
5099       size_t hash_entry_size;
5100       bfd_byte *bucketpos;
5101       bfd_vma chain;
5102
5103       sym.st_name = h->dynstr_index;
5104
5105       elf_swap_symbol_out (finfo->output_bfd, &sym,
5106                            (PTR) (((Elf_External_Sym *)
5107                                    finfo->dynsym_sec->contents)
5108                                   + h->dynindx));
5109
5110       bucketcount = elf_hash_table (finfo->info)->bucketcount;
5111       bucket = h->elf_hash_value % bucketcount;
5112       hash_entry_size
5113         = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
5114       bucketpos = ((bfd_byte *) finfo->hash_sec->contents
5115                    + (bucket + 2) * hash_entry_size);
5116       chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
5117       bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
5118       bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
5119                ((bfd_byte *) finfo->hash_sec->contents
5120                 + (bucketcount + 2 + h->dynindx) * hash_entry_size));
5121
5122       if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
5123         {
5124           Elf_Internal_Versym iversym;
5125
5126           if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
5127             {
5128               if (h->verinfo.verdef == NULL)
5129                 iversym.vs_vers = 0;
5130               else
5131                 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
5132             }
5133           else
5134             {
5135               if (h->verinfo.vertree == NULL)
5136                 iversym.vs_vers = 1;
5137               else
5138                 iversym.vs_vers = h->verinfo.vertree->vernum + 1;
5139             }
5140
5141           if ((h->elf_link_hash_flags & ELF_LINK_HIDDEN) != 0)
5142             iversym.vs_vers |= VERSYM_HIDDEN;
5143
5144           _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym,
5145                                     (((Elf_External_Versym *)
5146                                       finfo->symver_sec->contents)
5147                                      + h->dynindx));
5148         }
5149     }
5150
5151   /* If we're stripping it, then it was just a dynamic symbol, and
5152      there's nothing else to do.  */
5153   if (strip)
5154     return true;
5155
5156   h->indx = bfd_get_symcount (finfo->output_bfd);
5157
5158   if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
5159     {
5160       eoinfo->failed = true;
5161       return false;
5162     }
5163
5164   return true;
5165 }
5166
5167 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
5168    originated from the section given by INPUT_REL_HDR) to the
5169    OUTPUT_BFD.  */
5170
5171 static void
5172 elf_link_output_relocs (output_bfd, input_section, input_rel_hdr,
5173                         internal_relocs)
5174      bfd *output_bfd;
5175      asection *input_section;
5176      Elf_Internal_Shdr *input_rel_hdr;
5177      Elf_Internal_Rela *internal_relocs;
5178 {
5179   Elf_Internal_Rela *irela;
5180   Elf_Internal_Rela *irelaend;
5181   Elf_Internal_Shdr *output_rel_hdr;
5182   asection *output_section;
5183   unsigned int *rel_countp = NULL;
5184
5185   output_section = input_section->output_section;
5186   output_rel_hdr = NULL;
5187
5188   if (elf_section_data (output_section)->rel_hdr.sh_entsize
5189       == input_rel_hdr->sh_entsize)
5190     {
5191       output_rel_hdr = &elf_section_data (output_section)->rel_hdr;
5192       rel_countp = &elf_section_data (output_section)->rel_count;
5193     }
5194   else if (elf_section_data (output_section)->rel_hdr2
5195            && (elf_section_data (output_section)->rel_hdr2->sh_entsize
5196                == input_rel_hdr->sh_entsize))
5197     {
5198       output_rel_hdr = elf_section_data (output_section)->rel_hdr2;
5199       rel_countp = &elf_section_data (output_section)->rel_count2;
5200     }
5201
5202   BFD_ASSERT (output_rel_hdr != NULL);
5203
5204   irela = internal_relocs;
5205   irelaend = irela + input_rel_hdr->sh_size / input_rel_hdr->sh_entsize;
5206   if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
5207     {
5208       Elf_External_Rel *erel;
5209
5210       erel = ((Elf_External_Rel *) output_rel_hdr->contents + *rel_countp);
5211       for (; irela < irelaend; irela++, erel++)
5212         {
5213           Elf_Internal_Rel irel;
5214
5215           irel.r_offset = irela->r_offset;
5216           irel.r_info = irela->r_info;
5217           BFD_ASSERT (irela->r_addend == 0);
5218           elf_swap_reloc_out (output_bfd, &irel, erel);
5219         }
5220     }
5221   else
5222     {
5223       Elf_External_Rela *erela;
5224
5225       BFD_ASSERT (input_rel_hdr->sh_entsize
5226                   == sizeof (Elf_External_Rela));
5227       erela = ((Elf_External_Rela *) output_rel_hdr->contents + *rel_countp);
5228       for (; irela < irelaend; irela++, erela++)
5229         elf_swap_reloca_out (output_bfd, irela, erela);
5230     }
5231
5232   /* Bump the counter, so that we know where to add the next set of
5233      relocations.  */
5234   *rel_countp += input_rel_hdr->sh_size / input_rel_hdr->sh_entsize;
5235 }
5236
5237 /* Link an input file into the linker output file.  This function
5238    handles all the sections and relocations of the input file at once.
5239    This is so that we only have to read the local symbols once, and
5240    don't have to keep them in memory.  */
5241
5242 static boolean
5243 elf_link_input_bfd (finfo, input_bfd)
5244      struct elf_final_link_info *finfo;
5245      bfd *input_bfd;
5246 {
5247   boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
5248                                        bfd *, asection *, bfd_byte *,
5249                                        Elf_Internal_Rela *,
5250                                        Elf_Internal_Sym *, asection **));
5251   bfd *output_bfd;
5252   Elf_Internal_Shdr *symtab_hdr;
5253   size_t locsymcount;
5254   size_t extsymoff;
5255   Elf_External_Sym *external_syms;
5256   Elf_External_Sym *esym;
5257   Elf_External_Sym *esymend;
5258   Elf_Internal_Sym *isym;
5259   long *pindex;
5260   asection **ppsection;
5261   asection *o;
5262   struct elf_backend_data *bed;
5263
5264   output_bfd = finfo->output_bfd;
5265   bed = get_elf_backend_data (output_bfd);
5266   relocate_section = bed->elf_backend_relocate_section;
5267
5268   /* If this is a dynamic object, we don't want to do anything here:
5269      we don't want the local symbols, and we don't want the section
5270      contents.  */
5271   if ((input_bfd->flags & DYNAMIC) != 0)
5272     return true;
5273
5274   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5275   if (elf_bad_symtab (input_bfd))
5276     {
5277       locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
5278       extsymoff = 0;
5279     }
5280   else
5281     {
5282       locsymcount = symtab_hdr->sh_info;
5283       extsymoff = symtab_hdr->sh_info;
5284     }
5285
5286   /* Read the local symbols.  */
5287   if (symtab_hdr->contents != NULL)
5288     external_syms = (Elf_External_Sym *) symtab_hdr->contents;
5289   else if (locsymcount == 0)
5290     external_syms = NULL;
5291   else
5292     {
5293       external_syms = finfo->external_syms;
5294       if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
5295           || (bfd_read (external_syms, sizeof (Elf_External_Sym),
5296                         locsymcount, input_bfd)
5297               != locsymcount * sizeof (Elf_External_Sym)))
5298         return false;
5299     }
5300
5301   /* Swap in the local symbols and write out the ones which we know
5302      are going into the output file.  */
5303   esym = external_syms;
5304   esymend = esym + locsymcount;
5305   isym = finfo->internal_syms;
5306   pindex = finfo->indices;
5307   ppsection = finfo->sections;
5308   for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
5309     {
5310       asection *isec;
5311       const char *name;
5312       Elf_Internal_Sym osym;
5313
5314       elf_swap_symbol_in (input_bfd, esym, isym);
5315       *pindex = -1;
5316
5317       if (elf_bad_symtab (input_bfd))
5318         {
5319           if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
5320             {
5321               *ppsection = NULL;
5322               continue;
5323             }
5324         }
5325
5326       if (isym->st_shndx == SHN_UNDEF)
5327         isec = bfd_und_section_ptr;
5328       else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
5329         isec = section_from_elf_index (input_bfd, isym->st_shndx);
5330       else if (isym->st_shndx == SHN_ABS)
5331         isec = bfd_abs_section_ptr;
5332       else if (isym->st_shndx == SHN_COMMON)
5333         isec = bfd_com_section_ptr;
5334       else
5335         {
5336           /* Who knows?  */
5337           isec = NULL;
5338         }
5339
5340       *ppsection = isec;
5341
5342       /* Don't output the first, undefined, symbol.  */
5343       if (esym == external_syms)
5344         continue;
5345
5346       /* If we are stripping all symbols, we don't want to output this
5347          one.  */
5348       if (finfo->info->strip == strip_all)
5349         continue;
5350
5351       /* We never output section symbols.  Instead, we use the section
5352          symbol of the corresponding section in the output file.  */
5353       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
5354         continue;
5355
5356       /* If we are discarding all local symbols, we don't want to
5357          output this one.  If we are generating a relocateable output
5358          file, then some of the local symbols may be required by
5359          relocs; we output them below as we discover that they are
5360          needed.  */
5361       if (finfo->info->discard == discard_all)
5362         continue;
5363
5364       /* If this symbol is defined in a section which we are
5365          discarding, we don't need to keep it, but note that
5366          linker_mark is only reliable for sections that have contents.
5367          For the benefit of the MIPS ELF linker, we check SEC_EXCLUDE
5368          as well as linker_mark.  */
5369       if (isym->st_shndx > 0
5370           && isym->st_shndx < SHN_LORESERVE
5371           && isec != NULL
5372           && ((! isec->linker_mark && (isec->flags & SEC_HAS_CONTENTS) != 0)
5373               || (! finfo->info->relocateable
5374                   && (isec->flags & SEC_EXCLUDE) != 0)))
5375         continue;
5376
5377       /* Get the name of the symbol.  */
5378       name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
5379                                               isym->st_name);
5380       if (name == NULL)
5381         return false;
5382
5383       /* See if we are discarding symbols with this name.  */
5384       if ((finfo->info->strip == strip_some
5385            && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
5386                == NULL))
5387           || (finfo->info->discard == discard_l
5388               && bfd_is_local_label_name (input_bfd, name)))
5389         continue;
5390
5391       /* If we get here, we are going to output this symbol.  */
5392
5393       osym = *isym;
5394
5395       /* Adjust the section index for the output file.  */
5396       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
5397                                                          isec->output_section);
5398       if (osym.st_shndx == (unsigned short) -1)
5399         return false;
5400
5401       *pindex = bfd_get_symcount (output_bfd);
5402
5403       /* ELF symbols in relocateable files are section relative, but
5404          in executable files they are virtual addresses.  Note that
5405          this code assumes that all ELF sections have an associated
5406          BFD section with a reasonable value for output_offset; below
5407          we assume that they also have a reasonable value for
5408          output_section.  Any special sections must be set up to meet
5409          these requirements.  */
5410       osym.st_value += isec->output_offset;
5411       if (! finfo->info->relocateable)
5412         osym.st_value += isec->output_section->vma;
5413
5414       if (! elf_link_output_sym (finfo, name, &osym, isec))
5415         return false;
5416     }
5417
5418   /* Relocate the contents of each section.  */
5419   for (o = input_bfd->sections; o != NULL; o = o->next)
5420     {
5421       bfd_byte *contents;
5422
5423       if (! o->linker_mark)
5424         {
5425           /* This section was omitted from the link.  */
5426           continue;
5427         }
5428
5429       if ((o->flags & SEC_HAS_CONTENTS) == 0
5430           || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
5431         continue;
5432
5433       if ((o->flags & SEC_LINKER_CREATED) != 0)
5434         {
5435           /* Section was created by elf_link_create_dynamic_sections
5436              or somesuch.  */
5437           continue;
5438         }
5439
5440       /* Get the contents of the section.  They have been cached by a
5441          relaxation routine.  Note that o is a section in an input
5442          file, so the contents field will not have been set by any of
5443          the routines which work on output files.  */
5444       if (elf_section_data (o)->this_hdr.contents != NULL)
5445         contents = elf_section_data (o)->this_hdr.contents;
5446       else
5447         {
5448           contents = finfo->contents;
5449           if (! bfd_get_section_contents (input_bfd, o, contents,
5450                                           (file_ptr) 0, o->_raw_size))
5451             return false;
5452         }
5453
5454       if ((o->flags & SEC_RELOC) != 0)
5455         {
5456           Elf_Internal_Rela *internal_relocs;
5457
5458           /* Get the swapped relocs.  */
5459           internal_relocs = (NAME(_bfd_elf,link_read_relocs)
5460                              (input_bfd, o, finfo->external_relocs,
5461                               finfo->internal_relocs, false));
5462           if (internal_relocs == NULL
5463               && o->reloc_count > 0)
5464             return false;
5465
5466           /* Relocate the section by invoking a back end routine.
5467
5468              The back end routine is responsible for adjusting the
5469              section contents as necessary, and (if using Rela relocs
5470              and generating a relocateable output file) adjusting the
5471              reloc addend as necessary.
5472
5473              The back end routine does not have to worry about setting
5474              the reloc address or the reloc symbol index.
5475
5476              The back end routine is given a pointer to the swapped in
5477              internal symbols, and can access the hash table entries
5478              for the external symbols via elf_sym_hashes (input_bfd).
5479
5480              When generating relocateable output, the back end routine
5481              must handle STB_LOCAL/STT_SECTION symbols specially.  The
5482              output symbol is going to be a section symbol
5483              corresponding to the output section, which will require
5484              the addend to be adjusted.  */
5485
5486           if (! (*relocate_section) (output_bfd, finfo->info,
5487                                      input_bfd, o, contents,
5488                                      internal_relocs,
5489                                      finfo->internal_syms,
5490                                      finfo->sections))
5491             return false;
5492
5493           if (finfo->info->relocateable)
5494             {
5495               Elf_Internal_Rela *irela;
5496               Elf_Internal_Rela *irelaend;
5497               struct elf_link_hash_entry **rel_hash;
5498               Elf_Internal_Shdr *input_rel_hdr;
5499
5500               /* Adjust the reloc addresses and symbol indices.  */
5501
5502               irela = internal_relocs;
5503               irelaend =
5504                 irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
5505               rel_hash = (elf_section_data (o->output_section)->rel_hashes
5506                           + elf_section_data (o->output_section)->rel_count
5507                           + elf_section_data (o->output_section)->rel_count2);
5508               for (; irela < irelaend; irela++, rel_hash++)
5509                 {
5510                   unsigned long r_symndx;
5511                   Elf_Internal_Sym *isym;
5512                   asection *sec;
5513
5514                   irela->r_offset += o->output_offset;
5515
5516                   r_symndx = ELF_R_SYM (irela->r_info);
5517
5518                   if (r_symndx == 0)
5519                     continue;
5520
5521                   if (r_symndx >= locsymcount
5522                       || (elf_bad_symtab (input_bfd)
5523                           && finfo->sections[r_symndx] == NULL))
5524                     {
5525                       struct elf_link_hash_entry *rh;
5526                       long indx;
5527
5528                       /* This is a reloc against a global symbol.  We
5529                          have not yet output all the local symbols, so
5530                          we do not know the symbol index of any global
5531                          symbol.  We set the rel_hash entry for this
5532                          reloc to point to the global hash table entry
5533                          for this symbol.  The symbol index is then
5534                          set at the end of elf_bfd_final_link.  */
5535                       indx = r_symndx - extsymoff;
5536                       rh = elf_sym_hashes (input_bfd)[indx];
5537                       while (rh->root.type == bfd_link_hash_indirect
5538                              || rh->root.type == bfd_link_hash_warning)
5539                         rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
5540
5541                       /* Setting the index to -2 tells
5542                          elf_link_output_extsym that this symbol is
5543                          used by a reloc.  */
5544                       BFD_ASSERT (rh->indx < 0);
5545                       rh->indx = -2;
5546
5547                       *rel_hash = rh;
5548
5549                       continue;
5550                     }
5551
5552                   /* This is a reloc against a local symbol. */
5553
5554                   *rel_hash = NULL;
5555                   isym = finfo->internal_syms + r_symndx;
5556                   sec = finfo->sections[r_symndx];
5557                   if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
5558                     {
5559                       /* I suppose the backend ought to fill in the
5560                          section of any STT_SECTION symbol against a
5561                          processor specific section.  If we have
5562                          discarded a section, the output_section will
5563                          be the absolute section.  */
5564                       if (sec != NULL
5565                           && (bfd_is_abs_section (sec)
5566                               || (sec->output_section != NULL
5567                                   && bfd_is_abs_section (sec->output_section))))
5568                         r_symndx = 0;
5569                       else if (sec == NULL || sec->owner == NULL)
5570                         {
5571                           bfd_set_error (bfd_error_bad_value);
5572                           return false;
5573                         }
5574                       else
5575                         {
5576                           r_symndx = sec->output_section->target_index;
5577                           BFD_ASSERT (r_symndx != 0);
5578                         }
5579                     }
5580                   else
5581                     {
5582                       if (finfo->indices[r_symndx] == -1)
5583                         {
5584                           unsigned long link;
5585                           const char *name;
5586                           asection *osec;
5587
5588                           if (finfo->info->strip == strip_all)
5589                             {
5590                               /* You can't do ld -r -s.  */
5591                               bfd_set_error (bfd_error_invalid_operation);
5592                               return false;
5593                             }
5594
5595                           /* This symbol was skipped earlier, but
5596                              since it is needed by a reloc, we
5597                              must output it now.  */
5598                           link = symtab_hdr->sh_link;
5599                           name = bfd_elf_string_from_elf_section (input_bfd,
5600                                                                   link,
5601                                                                   isym->st_name);
5602                           if (name == NULL)
5603                             return false;
5604
5605                           osec = sec->output_section;
5606                           isym->st_shndx =
5607                             _bfd_elf_section_from_bfd_section (output_bfd,
5608                                                                osec);
5609                           if (isym->st_shndx == (unsigned short) -1)
5610                             return false;
5611
5612                           isym->st_value += sec->output_offset;
5613                           if (! finfo->info->relocateable)
5614                             isym->st_value += osec->vma;
5615
5616                           finfo->indices[r_symndx] = bfd_get_symcount (output_bfd);
5617
5618                           if (! elf_link_output_sym (finfo, name, isym, sec))
5619                             return false;
5620                         }
5621
5622                       r_symndx = finfo->indices[r_symndx];
5623                     }
5624
5625                   irela->r_info = ELF_R_INFO (r_symndx,
5626                                               ELF_R_TYPE (irela->r_info));
5627                 }
5628
5629               /* Swap out the relocs.  */
5630               input_rel_hdr = &elf_section_data (o)->rel_hdr;
5631               elf_link_output_relocs (output_bfd, o,
5632                                       input_rel_hdr,
5633                                       internal_relocs);
5634               internal_relocs
5635                 += input_rel_hdr->sh_size / input_rel_hdr->sh_entsize;
5636               input_rel_hdr = elf_section_data (o)->rel_hdr2;
5637               if (input_rel_hdr)
5638                 elf_link_output_relocs (output_bfd, o,
5639                                         input_rel_hdr,
5640                                         internal_relocs);
5641             }
5642         }
5643
5644       /* Write out the modified section contents.  */
5645       if (elf_section_data (o)->stab_info == NULL)
5646         {
5647           if (! (o->flags & SEC_EXCLUDE) &&
5648               ! bfd_set_section_contents (output_bfd, o->output_section,
5649                                           contents, o->output_offset,
5650                                           (o->_cooked_size != 0
5651                                            ? o->_cooked_size
5652                                            : o->_raw_size)))
5653             return false;
5654         }
5655       else
5656         {
5657           if (! (_bfd_write_section_stabs
5658                  (output_bfd, &elf_hash_table (finfo->info)->stab_info,
5659                   o, &elf_section_data (o)->stab_info, contents)))
5660             return false;
5661         }
5662     }
5663
5664   return true;
5665 }
5666
5667 /* Generate a reloc when linking an ELF file.  This is a reloc
5668    requested by the linker, and does come from any input file.  This
5669    is used to build constructor and destructor tables when linking
5670    with -Ur.  */
5671
5672 static boolean
5673 elf_reloc_link_order (output_bfd, info, output_section, link_order)
5674      bfd *output_bfd;
5675      struct bfd_link_info *info;
5676      asection *output_section;
5677      struct bfd_link_order *link_order;
5678 {
5679   reloc_howto_type *howto;
5680   long indx;
5681   bfd_vma offset;
5682   bfd_vma addend;
5683   struct elf_link_hash_entry **rel_hash_ptr;
5684   Elf_Internal_Shdr *rel_hdr;
5685
5686   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
5687   if (howto == NULL)
5688     {
5689       bfd_set_error (bfd_error_bad_value);
5690       return false;
5691     }
5692
5693   addend = link_order->u.reloc.p->addend;
5694
5695   /* Figure out the symbol index.  */
5696   rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
5697                   + elf_section_data (output_section)->rel_count
5698                   + elf_section_data (output_section)->rel_count2);
5699   if (link_order->type == bfd_section_reloc_link_order)
5700     {
5701       indx = link_order->u.reloc.p->u.section->target_index;
5702       BFD_ASSERT (indx != 0);
5703       *rel_hash_ptr = NULL;
5704     }
5705   else
5706     {
5707       struct elf_link_hash_entry *h;
5708
5709       /* Treat a reloc against a defined symbol as though it were
5710          actually against the section.  */
5711       h = ((struct elf_link_hash_entry *)
5712            bfd_wrapped_link_hash_lookup (output_bfd, info,
5713                                          link_order->u.reloc.p->u.name,
5714                                          false, false, true));
5715       if (h != NULL
5716           && (h->root.type == bfd_link_hash_defined
5717               || h->root.type == bfd_link_hash_defweak))
5718         {
5719           asection *section;
5720
5721           section = h->root.u.def.section;
5722           indx = section->output_section->target_index;
5723           *rel_hash_ptr = NULL;
5724           /* It seems that we ought to add the symbol value to the
5725              addend here, but in practice it has already been added
5726              because it was passed to constructor_callback.  */
5727           addend += section->output_section->vma + section->output_offset;
5728         }
5729       else if (h != NULL)
5730         {
5731           /* Setting the index to -2 tells elf_link_output_extsym that
5732              this symbol is used by a reloc.  */
5733           h->indx = -2;
5734           *rel_hash_ptr = h;
5735           indx = 0;
5736         }
5737       else
5738         {
5739           if (! ((*info->callbacks->unattached_reloc)
5740                  (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
5741                   (asection *) NULL, (bfd_vma) 0)))
5742             return false;
5743           indx = 0;
5744         }
5745     }
5746
5747   /* If this is an inplace reloc, we must write the addend into the
5748      object file.  */
5749   if (howto->partial_inplace && addend != 0)
5750     {
5751       bfd_size_type size;
5752       bfd_reloc_status_type rstat;
5753       bfd_byte *buf;
5754       boolean ok;
5755
5756       size = bfd_get_reloc_size (howto);
5757       buf = (bfd_byte *) bfd_zmalloc (size);
5758       if (buf == (bfd_byte *) NULL)
5759         return false;
5760       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
5761       switch (rstat)
5762         {
5763         case bfd_reloc_ok:
5764           break;
5765         default:
5766         case bfd_reloc_outofrange:
5767           abort ();
5768         case bfd_reloc_overflow:
5769           if (! ((*info->callbacks->reloc_overflow)
5770                  (info,
5771                   (link_order->type == bfd_section_reloc_link_order
5772                    ? bfd_section_name (output_bfd,
5773                                        link_order->u.reloc.p->u.section)
5774                    : link_order->u.reloc.p->u.name),
5775                   howto->name, addend, (bfd *) NULL, (asection *) NULL,
5776                   (bfd_vma) 0)))
5777             {
5778               free (buf);
5779               return false;
5780             }
5781           break;
5782         }
5783       ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
5784                                      (file_ptr) link_order->offset, size);
5785       free (buf);
5786       if (! ok)
5787         return false;
5788     }
5789
5790   /* The address of a reloc is relative to the section in a
5791      relocateable file, and is a virtual address in an executable
5792      file.  */
5793   offset = link_order->offset;
5794   if (! info->relocateable)
5795     offset += output_section->vma;
5796
5797   rel_hdr = &elf_section_data (output_section)->rel_hdr;
5798
5799   if (rel_hdr->sh_type == SHT_REL)
5800     {
5801       Elf_Internal_Rel irel;
5802       Elf_External_Rel *erel;
5803
5804       irel.r_offset = offset;
5805       irel.r_info = ELF_R_INFO (indx, howto->type);
5806       erel = ((Elf_External_Rel *) rel_hdr->contents
5807               + elf_section_data (output_section)->rel_count);
5808       elf_swap_reloc_out (output_bfd, &irel, erel);
5809     }
5810   else
5811     {
5812       Elf_Internal_Rela irela;
5813       Elf_External_Rela *erela;
5814
5815       irela.r_offset = offset;
5816       irela.r_info = ELF_R_INFO (indx, howto->type);
5817       irela.r_addend = addend;
5818       erela = ((Elf_External_Rela *) rel_hdr->contents
5819                + elf_section_data (output_section)->rel_count);
5820       elf_swap_reloca_out (output_bfd, &irela, erela);
5821     }
5822
5823   ++elf_section_data (output_section)->rel_count;
5824
5825   return true;
5826 }
5827
5828 \f
5829 /* Allocate a pointer to live in a linker created section.  */
5830
5831 boolean
5832 elf_create_pointer_linker_section (abfd, info, lsect, h, rel)
5833      bfd *abfd;
5834      struct bfd_link_info *info;
5835      elf_linker_section_t *lsect;
5836      struct elf_link_hash_entry *h;
5837      const Elf_Internal_Rela *rel;
5838 {
5839   elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
5840   elf_linker_section_pointers_t *linker_section_ptr;
5841   unsigned long r_symndx = ELF_R_SYM (rel->r_info);;
5842
5843   BFD_ASSERT (lsect != NULL);
5844
5845   /* Is this a global symbol? */
5846   if (h != NULL)
5847     {
5848       /* Has this symbol already been allocated, if so, our work is done */
5849       if (_bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
5850                                                 rel->r_addend,
5851                                                 lsect->which))
5852         return true;
5853
5854       ptr_linker_section_ptr = &h->linker_section_pointer;
5855       /* Make sure this symbol is output as a dynamic symbol.  */
5856       if (h->dynindx == -1)
5857         {
5858           if (! elf_link_record_dynamic_symbol (info, h))
5859             return false;
5860         }
5861
5862       if (lsect->rel_section)
5863         lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
5864     }
5865
5866   else  /* Allocation of a pointer to a local symbol */
5867     {
5868       elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
5869
5870       /* Allocate a table to hold the local symbols if first time */
5871       if (!ptr)
5872         {
5873           unsigned int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info;
5874           register unsigned int i;
5875
5876           ptr = (elf_linker_section_pointers_t **)
5877             bfd_alloc (abfd, num_symbols * sizeof (elf_linker_section_pointers_t *));
5878
5879           if (!ptr)
5880             return false;
5881
5882           elf_local_ptr_offsets (abfd) = ptr;
5883           for (i = 0; i < num_symbols; i++)
5884             ptr[i] = (elf_linker_section_pointers_t *)0;
5885         }
5886
5887       /* Has this symbol already been allocated, if so, our work is done */
5888       if (_bfd_elf_find_pointer_linker_section (ptr[r_symndx],
5889                                                 rel->r_addend,
5890                                                 lsect->which))
5891         return true;
5892
5893       ptr_linker_section_ptr = &ptr[r_symndx];
5894
5895       if (info->shared)
5896         {
5897           /* If we are generating a shared object, we need to
5898              output a R_<xxx>_RELATIVE reloc so that the
5899              dynamic linker can adjust this GOT entry.  */
5900           BFD_ASSERT (lsect->rel_section != NULL);
5901           lsect->rel_section->_raw_size += sizeof (Elf_External_Rela);
5902         }
5903     }
5904
5905   /* Allocate space for a pointer in the linker section, and allocate a new pointer record
5906      from internal memory.  */
5907   BFD_ASSERT (ptr_linker_section_ptr != NULL);
5908   linker_section_ptr = (elf_linker_section_pointers_t *)
5909     bfd_alloc (abfd, sizeof (elf_linker_section_pointers_t));
5910
5911   if (!linker_section_ptr)
5912     return false;
5913
5914   linker_section_ptr->next = *ptr_linker_section_ptr;
5915   linker_section_ptr->addend = rel->r_addend;
5916   linker_section_ptr->which = lsect->which;
5917   linker_section_ptr->written_address_p = false;
5918   *ptr_linker_section_ptr = linker_section_ptr;
5919
5920 #if 0
5921   if (lsect->hole_size && lsect->hole_offset < lsect->max_hole_offset)
5922     {
5923       linker_section_ptr->offset = lsect->section->_raw_size - lsect->hole_size + (ARCH_SIZE / 8);
5924       lsect->hole_offset += ARCH_SIZE / 8;
5925       lsect->sym_offset  += ARCH_SIZE / 8;
5926       if (lsect->sym_hash)      /* Bump up symbol value if needed */
5927         {
5928           lsect->sym_hash->root.u.def.value += ARCH_SIZE / 8;
5929 #ifdef DEBUG
5930           fprintf (stderr, "Bump up %s by %ld, current value = %ld\n",
5931                    lsect->sym_hash->root.root.string,
5932                    (long)ARCH_SIZE / 8,
5933                    (long)lsect->sym_hash->root.u.def.value);
5934 #endif
5935         }
5936     }
5937   else
5938 #endif
5939     linker_section_ptr->offset = lsect->section->_raw_size;
5940
5941   lsect->section->_raw_size += ARCH_SIZE / 8;
5942
5943 #ifdef DEBUG
5944   fprintf (stderr, "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
5945            lsect->name, (long)linker_section_ptr->offset, (long)lsect->section->_raw_size);
5946 #endif
5947
5948   return true;
5949 }
5950
5951 \f
5952 #if ARCH_SIZE==64
5953 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_64 (BFD, VAL, ADDR)
5954 #endif
5955 #if ARCH_SIZE==32
5956 #define bfd_put_ptr(BFD,VAL,ADDR) bfd_put_32 (BFD, VAL, ADDR)
5957 #endif
5958
5959 /* Fill in the address for a pointer generated in alinker section.  */
5960
5961 bfd_vma
5962 elf_finish_pointer_linker_section (output_bfd, input_bfd, info, lsect, h, relocation, rel, relative_reloc)
5963      bfd *output_bfd;
5964      bfd *input_bfd;
5965      struct bfd_link_info *info;
5966      elf_linker_section_t *lsect;
5967      struct elf_link_hash_entry *h;
5968      bfd_vma relocation;
5969      const Elf_Internal_Rela *rel;
5970      int relative_reloc;
5971 {
5972   elf_linker_section_pointers_t *linker_section_ptr;
5973
5974   BFD_ASSERT (lsect != NULL);
5975
5976   if (h != NULL)                /* global symbol */
5977     {
5978       linker_section_ptr = _bfd_elf_find_pointer_linker_section (h->linker_section_pointer,
5979                                                                  rel->r_addend,
5980                                                                  lsect->which);
5981
5982       BFD_ASSERT (linker_section_ptr != NULL);
5983
5984       if (! elf_hash_table (info)->dynamic_sections_created
5985           || (info->shared
5986               && info->symbolic
5987               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5988         {
5989           /* This is actually a static link, or it is a
5990              -Bsymbolic link and the symbol is defined
5991              locally.  We must initialize this entry in the
5992              global section.
5993
5994              When doing a dynamic link, we create a .rela.<xxx>
5995              relocation entry to initialize the value.  This
5996              is done in the finish_dynamic_symbol routine.  */
5997           if (!linker_section_ptr->written_address_p)
5998             {
5999               linker_section_ptr->written_address_p = true;
6000               bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
6001                           lsect->section->contents + linker_section_ptr->offset);
6002             }
6003         }
6004     }
6005   else                          /* local symbol */
6006     {
6007       unsigned long r_symndx = ELF_R_SYM (rel->r_info);
6008       BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
6009       BFD_ASSERT (elf_local_ptr_offsets (input_bfd)[r_symndx] != NULL);
6010       linker_section_ptr = _bfd_elf_find_pointer_linker_section (elf_local_ptr_offsets (input_bfd)[r_symndx],
6011                                                                  rel->r_addend,
6012                                                                  lsect->which);
6013
6014       BFD_ASSERT (linker_section_ptr != NULL);
6015
6016       /* Write out pointer if it hasn't been rewritten out before */
6017       if (!linker_section_ptr->written_address_p)
6018         {
6019           linker_section_ptr->written_address_p = true;
6020           bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
6021                        lsect->section->contents + linker_section_ptr->offset);
6022
6023           if (info->shared)
6024             {
6025               asection *srel = lsect->rel_section;
6026               Elf_Internal_Rela outrel;
6027
6028               /* We need to generate a relative reloc for the dynamic linker.  */
6029               if (!srel)
6030                 lsect->rel_section = srel = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
6031                                                                      lsect->rel_name);
6032
6033               BFD_ASSERT (srel != NULL);
6034
6035               outrel.r_offset = (lsect->section->output_section->vma
6036                                  + lsect->section->output_offset
6037                                  + linker_section_ptr->offset);
6038               outrel.r_info = ELF_R_INFO (0, relative_reloc);
6039               outrel.r_addend = 0;
6040               elf_swap_reloca_out (output_bfd, &outrel,
6041                                    (((Elf_External_Rela *)
6042                                      lsect->section->contents)
6043                                     + elf_section_data (lsect->section)->rel_count));
6044               ++elf_section_data (lsect->section)->rel_count;
6045             }
6046         }
6047     }
6048
6049   relocation = (lsect->section->output_offset
6050                 + linker_section_ptr->offset
6051                 - lsect->hole_offset
6052                 - lsect->sym_offset);
6053
6054 #ifdef DEBUG
6055   fprintf (stderr, "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
6056            lsect->name, (long)relocation, (long)relocation);
6057 #endif
6058
6059   /* Subtract out the addend, because it will get added back in by the normal
6060      processing.  */
6061   return relocation - linker_section_ptr->addend;
6062 }
6063 \f
6064 /* Garbage collect unused sections.  */
6065
6066 static boolean elf_gc_mark
6067   PARAMS ((struct bfd_link_info *info, asection *sec,
6068            asection * (*gc_mark_hook)
6069              PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
6070                       struct elf_link_hash_entry *, Elf_Internal_Sym *))));
6071
6072 static boolean elf_gc_sweep
6073   PARAMS ((struct bfd_link_info *info,
6074            boolean (*gc_sweep_hook)
6075              PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *o,
6076                       const Elf_Internal_Rela *relocs))));
6077
6078 static boolean elf_gc_sweep_symbol
6079   PARAMS ((struct elf_link_hash_entry *h, PTR idxptr));
6080
6081 static boolean elf_gc_allocate_got_offsets
6082   PARAMS ((struct elf_link_hash_entry *h, PTR offarg));
6083
6084 static boolean elf_gc_propagate_vtable_entries_used
6085   PARAMS ((struct elf_link_hash_entry *h, PTR dummy));
6086
6087 static boolean elf_gc_smash_unused_vtentry_relocs
6088   PARAMS ((struct elf_link_hash_entry *h, PTR dummy));
6089
6090 /* The mark phase of garbage collection.  For a given section, mark
6091    it, and all the sections which define symbols to which it refers.  */
6092
6093 static boolean
6094 elf_gc_mark (info, sec, gc_mark_hook)
6095      struct bfd_link_info *info;
6096      asection *sec;
6097      asection * (*gc_mark_hook)
6098        PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
6099                 struct elf_link_hash_entry *, Elf_Internal_Sym *));
6100 {
6101   boolean ret = true;
6102
6103   sec->gc_mark = 1;
6104
6105   /* Look through the section relocs.  */
6106
6107   if ((sec->flags & SEC_RELOC) != 0 && sec->reloc_count > 0)
6108     {
6109       Elf_Internal_Rela *relstart, *rel, *relend;
6110       Elf_Internal_Shdr *symtab_hdr;
6111       struct elf_link_hash_entry **sym_hashes;
6112       size_t nlocsyms;
6113       size_t extsymoff;
6114       Elf_External_Sym *locsyms, *freesyms = NULL;
6115       bfd *input_bfd = sec->owner;
6116       struct elf_backend_data *bed = get_elf_backend_data (input_bfd);
6117
6118       /* GCFIXME: how to arrange so that relocs and symbols are not
6119          reread continually?  */
6120
6121       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6122       sym_hashes = elf_sym_hashes (input_bfd);
6123
6124       /* Read the local symbols.  */
6125       if (elf_bad_symtab (input_bfd))
6126         {
6127           nlocsyms = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
6128           extsymoff = 0;
6129         }
6130       else
6131         extsymoff = nlocsyms = symtab_hdr->sh_info;
6132       if (symtab_hdr->contents)
6133         locsyms = (Elf_External_Sym *) symtab_hdr->contents;
6134       else if (nlocsyms == 0)
6135         locsyms = NULL;
6136       else
6137         {
6138           locsyms = freesyms =
6139             bfd_malloc (nlocsyms * sizeof (Elf_External_Sym));
6140           if (freesyms == NULL
6141               || bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
6142               || (bfd_read (locsyms, sizeof (Elf_External_Sym),
6143                             nlocsyms, input_bfd)
6144                   != nlocsyms * sizeof (Elf_External_Sym)))
6145             {
6146               ret = false;
6147               goto out1;
6148             }
6149         }
6150
6151       /* Read the relocations.  */
6152       relstart = (NAME(_bfd_elf,link_read_relocs)
6153                   (sec->owner, sec, NULL, (Elf_Internal_Rela *) NULL,
6154                    info->keep_memory));
6155       if (relstart == NULL)
6156         {
6157           ret = false;
6158           goto out1;
6159         }
6160       relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
6161
6162       for (rel = relstart; rel < relend; rel++)
6163         {
6164           unsigned long r_symndx;
6165           asection *rsec;
6166           struct elf_link_hash_entry *h;
6167           Elf_Internal_Sym s;
6168
6169           r_symndx = ELF_R_SYM (rel->r_info);
6170           if (r_symndx == 0)
6171             continue;
6172
6173           if (elf_bad_symtab (sec->owner))
6174             {
6175               elf_swap_symbol_in (input_bfd, &locsyms[r_symndx], &s);
6176               if (ELF_ST_BIND (s.st_info) == STB_LOCAL)
6177                 rsec = (*gc_mark_hook)(sec->owner, info, rel, NULL, &s);
6178               else
6179                 {
6180                   h = sym_hashes[r_symndx - extsymoff];
6181                   rsec = (*gc_mark_hook)(sec->owner, info, rel, h, NULL);
6182                 }
6183             }
6184           else if (r_symndx >= nlocsyms)
6185             {
6186               h = sym_hashes[r_symndx - extsymoff];
6187               rsec = (*gc_mark_hook)(sec->owner, info, rel, h, NULL);
6188             }
6189           else
6190             {
6191               elf_swap_symbol_in (input_bfd, &locsyms[r_symndx], &s);
6192               rsec = (*gc_mark_hook)(sec->owner, info, rel, NULL, &s);
6193             }
6194
6195           if (rsec && !rsec->gc_mark)
6196             if (!elf_gc_mark (info, rsec, gc_mark_hook))
6197               {
6198                 ret = false;
6199                 goto out2;
6200               }
6201         }
6202
6203     out2:
6204       if (!info->keep_memory)
6205         free (relstart);
6206     out1:
6207       if (freesyms)
6208         free (freesyms);
6209     }
6210
6211   return ret;
6212 }
6213
6214 /* The sweep phase of garbage collection.  Remove all garbage sections.  */
6215
6216 static boolean
6217 elf_gc_sweep (info, gc_sweep_hook)
6218      struct bfd_link_info *info;
6219      boolean (*gc_sweep_hook)
6220        PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *o,
6221                 const Elf_Internal_Rela *relocs));
6222 {
6223   bfd *sub;
6224
6225   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
6226     {
6227       asection *o;
6228
6229       for (o = sub->sections; o != NULL; o = o->next)
6230         {
6231           /* Keep special sections.  Keep .debug sections.  */
6232           if ((o->flags & SEC_LINKER_CREATED)
6233               || (o->flags & SEC_DEBUGGING))
6234             o->gc_mark = 1;
6235
6236           if (o->gc_mark)
6237             continue;
6238
6239           /* Skip sweeping sections already excluded.  */
6240           if (o->flags & SEC_EXCLUDE)
6241             continue;
6242
6243           /* Since this is early in the link process, it is simple
6244              to remove a section from the output.  */
6245           o->flags |= SEC_EXCLUDE;
6246
6247           /* But we also have to update some of the relocation
6248              info we collected before.  */
6249           if (gc_sweep_hook
6250               && (o->flags & SEC_RELOC) && o->reloc_count > 0)
6251             {
6252               Elf_Internal_Rela *internal_relocs;
6253               boolean r;
6254
6255               internal_relocs = (NAME(_bfd_elf,link_read_relocs)
6256                                  (o->owner, o, NULL, NULL, info->keep_memory));
6257               if (internal_relocs == NULL)
6258                 return false;
6259
6260               r = (*gc_sweep_hook)(o->owner, info, o, internal_relocs);
6261
6262               if (!info->keep_memory)
6263                 free (internal_relocs);
6264
6265               if (!r)
6266                 return false;
6267             }
6268         }
6269     }
6270
6271   /* Remove the symbols that were in the swept sections from the dynamic
6272      symbol table.  GCFIXME: Anyone know how to get them out of the
6273      static symbol table as well?  */
6274   {
6275     int i = 0;
6276
6277     elf_link_hash_traverse (elf_hash_table (info),
6278                             elf_gc_sweep_symbol,
6279                             (PTR) &i);
6280
6281     elf_hash_table (info)->dynsymcount = i;
6282   }
6283
6284   return true;
6285 }
6286
6287 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
6288
6289 static boolean
6290 elf_gc_sweep_symbol (h, idxptr)
6291      struct elf_link_hash_entry *h;
6292      PTR idxptr;
6293 {
6294   int *idx = (int *) idxptr;
6295
6296   if (h->dynindx != -1
6297       && ((h->root.type != bfd_link_hash_defined
6298            && h->root.type != bfd_link_hash_defweak)
6299           || h->root.u.def.section->gc_mark))
6300     h->dynindx = (*idx)++;
6301
6302   return true;
6303 }
6304
6305 /* Propogate collected vtable information.  This is called through
6306    elf_link_hash_traverse.  */
6307
6308 static boolean
6309 elf_gc_propagate_vtable_entries_used (h, okp)
6310      struct elf_link_hash_entry *h;
6311      PTR okp;
6312 {
6313   /* Those that are not vtables. */
6314   if (h->vtable_parent == NULL)
6315     return true;
6316
6317   /* Those vtables that do not have parents, we cannot merge.  */
6318   if (h->vtable_parent == (struct elf_link_hash_entry *) -1)
6319     return true;
6320
6321   /* If we've already been done, exit.  */
6322   if (h->vtable_entries_used && h->vtable_entries_used[-1])
6323     return true;
6324
6325   /* Make sure the parent's table is up to date.  */
6326   elf_gc_propagate_vtable_entries_used (h->vtable_parent, okp);
6327
6328   if (h->vtable_entries_used == NULL)
6329     {
6330       /* None of this table's entries were referenced.  Re-use the
6331          parent's table.  */
6332       h->vtable_entries_used = h->vtable_parent->vtable_entries_used;
6333       h->vtable_entries_size = h->vtable_parent->vtable_entries_size;
6334     }
6335   else
6336     {
6337       size_t n;
6338       boolean *cu, *pu;
6339
6340       /* Or the parent's entries into ours.  */
6341       cu = h->vtable_entries_used;
6342       cu[-1] = true;
6343       pu = h->vtable_parent->vtable_entries_used;
6344       if (pu != NULL)
6345         {
6346           n = h->vtable_parent->vtable_entries_size / FILE_ALIGN;
6347           while (--n != 0)
6348             {
6349               if (*pu) *cu = true;
6350               pu++, cu++;
6351             }
6352         }
6353     }
6354
6355   return true;
6356 }
6357
6358 static boolean
6359 elf_gc_smash_unused_vtentry_relocs (h, okp)
6360      struct elf_link_hash_entry *h;
6361      PTR okp;
6362 {
6363   asection *sec;
6364   bfd_vma hstart, hend;
6365   Elf_Internal_Rela *relstart, *relend, *rel;
6366   struct elf_backend_data *bed;
6367
6368   /* Take care of both those symbols that do not describe vtables as
6369      well as those that are not loaded.  */
6370   if (h->vtable_parent == NULL)
6371     return true;
6372
6373   BFD_ASSERT (h->root.type == bfd_link_hash_defined
6374               || h->root.type == bfd_link_hash_defweak);
6375
6376   sec = h->root.u.def.section;
6377   hstart = h->root.u.def.value;
6378   hend = hstart + h->size;
6379
6380   relstart = (NAME(_bfd_elf,link_read_relocs)
6381               (sec->owner, sec, NULL, (Elf_Internal_Rela *) NULL, true));
6382   if (!relstart)
6383     return *(boolean *)okp = false;
6384   bed = get_elf_backend_data (sec->owner);
6385   relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
6386
6387   for (rel = relstart; rel < relend; ++rel)
6388     if (rel->r_offset >= hstart && rel->r_offset < hend)
6389       {
6390         /* If the entry is in use, do nothing.  */
6391         if (h->vtable_entries_used
6392             && (rel->r_offset - hstart) < h->vtable_entries_size)
6393           {
6394             bfd_vma entry = (rel->r_offset - hstart) / FILE_ALIGN;
6395             if (h->vtable_entries_used[entry])
6396               continue;
6397           }
6398         /* Otherwise, kill it.  */
6399         rel->r_offset = rel->r_info = rel->r_addend = 0;
6400       }
6401
6402   return true;
6403 }
6404
6405 /* Do mark and sweep of unused sections.  */
6406
6407 boolean
6408 elf_gc_sections (abfd, info)
6409      bfd *abfd;
6410      struct bfd_link_info *info;
6411 {
6412   boolean ok = true;
6413   bfd *sub;
6414   asection * (*gc_mark_hook)
6415     PARAMS ((bfd *abfd, struct bfd_link_info *, Elf_Internal_Rela *,
6416              struct elf_link_hash_entry *h, Elf_Internal_Sym *));
6417
6418   if (!get_elf_backend_data (abfd)->can_gc_sections
6419       || info->relocateable
6420       || elf_hash_table (info)->dynamic_sections_created)
6421     return true;
6422
6423   /* Apply transitive closure to the vtable entry usage info.  */
6424   elf_link_hash_traverse (elf_hash_table (info),
6425                           elf_gc_propagate_vtable_entries_used,
6426                           (PTR) &ok);
6427   if (!ok)
6428     return false;
6429
6430   /* Kill the vtable relocations that were not used.  */
6431   elf_link_hash_traverse (elf_hash_table (info),
6432                           elf_gc_smash_unused_vtentry_relocs,
6433                           (PTR) &ok);
6434   if (!ok)
6435     return false;
6436
6437   /* Grovel through relocs to find out who stays ...  */
6438
6439   gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
6440   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
6441     {
6442       asection *o;
6443       for (o = sub->sections; o != NULL; o = o->next)
6444         {
6445           if (o->flags & SEC_KEEP)
6446             if (!elf_gc_mark (info, o, gc_mark_hook))
6447               return false;
6448         }
6449     }
6450
6451   /* ... and mark SEC_EXCLUDE for those that go.  */
6452   if (!elf_gc_sweep(info, get_elf_backend_data (abfd)->gc_sweep_hook))
6453     return false;
6454
6455   return true;
6456 }
6457 \f
6458 /* Called from check_relocs to record the existance of a VTINHERIT reloc.  */
6459
6460 boolean
6461 elf_gc_record_vtinherit (abfd, sec, h, offset)
6462      bfd *abfd;
6463      asection *sec;
6464      struct elf_link_hash_entry *h;
6465      bfd_vma offset;
6466 {
6467   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6468   struct elf_link_hash_entry **search, *child;
6469   bfd_size_type extsymcount;
6470
6471   /* The sh_info field of the symtab header tells us where the
6472      external symbols start.  We don't care about the local symbols at
6473      this point.  */
6474   extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size/sizeof (Elf_External_Sym);
6475   if (!elf_bad_symtab (abfd))
6476     extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
6477
6478   sym_hashes = elf_sym_hashes (abfd);
6479   sym_hashes_end = sym_hashes + extsymcount;
6480
6481   /* Hunt down the child symbol, which is in this section at the same
6482      offset as the relocation.  */
6483   for (search = sym_hashes; search != sym_hashes_end; ++search)
6484     {
6485       if ((child = *search) != NULL
6486           && (child->root.type == bfd_link_hash_defined
6487               || child->root.type == bfd_link_hash_defweak)
6488           && child->root.u.def.section == sec
6489           && child->root.u.def.value == offset)
6490         goto win;
6491     }
6492
6493   (*_bfd_error_handler) ("%s: %s+%lu: No symbol found for INHERIT",
6494                          bfd_get_filename (abfd), sec->name,
6495                          (unsigned long)offset);
6496   bfd_set_error (bfd_error_invalid_operation);
6497   return false;
6498
6499 win:
6500   if (!h)
6501     {
6502       /* This *should* only be the absolute section.  It could potentially
6503          be that someone has defined a non-global vtable though, which
6504          would be bad.  It isn't worth paging in the local symbols to be
6505          sure though; that case should simply be handled by the assembler.  */
6506
6507       child->vtable_parent = (struct elf_link_hash_entry *) -1;
6508     }
6509   else
6510     child->vtable_parent = h;
6511
6512   return true;
6513 }
6514
6515 /* Called from check_relocs to record the existance of a VTENTRY reloc.  */
6516
6517 boolean
6518 elf_gc_record_vtentry (abfd, sec, h, addend)
6519      bfd *abfd ATTRIBUTE_UNUSED;
6520      asection *sec ATTRIBUTE_UNUSED;
6521      struct elf_link_hash_entry *h;
6522      bfd_vma addend;
6523 {
6524   if (addend >= h->vtable_entries_size)
6525     {
6526       size_t size, bytes;
6527       boolean *ptr = h->vtable_entries_used;
6528
6529       /* While the symbol is undefined, we have to be prepared to handle
6530          a zero size.  */
6531       if (h->root.type == bfd_link_hash_undefined)
6532         size = addend;
6533       else
6534         {
6535           size = h->size;
6536           if (size < addend)
6537             {
6538               /* Oops!  We've got a reference past the defined end of
6539                  the table.  This is probably a bug -- shall we warn?  */
6540               size = addend;
6541             }
6542         }
6543
6544       /* Allocate one extra entry for use as a "done" flag for the
6545          consolidation pass.  */
6546       bytes = (size / FILE_ALIGN + 1) * sizeof (boolean);
6547
6548       if (ptr)
6549         {
6550           ptr = bfd_realloc (ptr - 1, bytes);
6551
6552           if (ptr != NULL)
6553             {
6554               size_t oldbytes;
6555
6556               oldbytes = (h->vtable_entries_size/FILE_ALIGN + 1) * sizeof (boolean);
6557               memset (((char *)ptr) + oldbytes, 0, bytes - oldbytes);
6558             }
6559         }
6560       else
6561         ptr = bfd_zmalloc (bytes);
6562
6563       if (ptr == NULL)
6564         return false;
6565
6566       /* And arrange for that done flag to be at index -1.  */
6567       h->vtable_entries_used = ptr + 1;
6568       h->vtable_entries_size = size;
6569     }
6570
6571   h->vtable_entries_used[addend / FILE_ALIGN] = true;
6572
6573   return true;
6574 }
6575
6576 /* And an accompanying bit to work out final got entry offsets once
6577    we're done.  Should be called from final_link.  */
6578
6579 boolean
6580 elf_gc_common_finalize_got_offsets (abfd, info)
6581      bfd *abfd;
6582      struct bfd_link_info *info;
6583 {
6584   bfd *i;
6585   struct elf_backend_data *bed = get_elf_backend_data (abfd);
6586   bfd_vma gotoff;
6587
6588   /* The GOT offset is relative to the .got section, but the GOT header is
6589      put into the .got.plt section, if the backend uses it.  */
6590   if (bed->want_got_plt)
6591     gotoff = 0;
6592   else
6593     gotoff = bed->got_header_size;
6594
6595   /* Do the local .got entries first.  */
6596   for (i = info->input_bfds; i; i = i->link_next)
6597     {
6598       bfd_signed_vma *local_got = elf_local_got_refcounts (i);
6599       bfd_size_type j, locsymcount;
6600       Elf_Internal_Shdr *symtab_hdr;
6601
6602       if (!local_got)
6603         continue;
6604
6605       symtab_hdr = &elf_tdata (i)->symtab_hdr;
6606       if (elf_bad_symtab (i))
6607         locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
6608       else
6609         locsymcount = symtab_hdr->sh_info;
6610
6611       for (j = 0; j < locsymcount; ++j)
6612         {
6613           if (local_got[j] > 0)
6614             {
6615               local_got[j] = gotoff;
6616               gotoff += ARCH_SIZE / 8;
6617             }
6618           else
6619             local_got[j] = (bfd_vma) -1;
6620         }
6621     }
6622
6623   /* Then the global .got and .plt entries.  */
6624   elf_link_hash_traverse (elf_hash_table (info),
6625                           elf_gc_allocate_got_offsets,
6626                           (PTR) &gotoff);
6627   return true;
6628 }
6629
6630 /* We need a special top-level link routine to convert got reference counts
6631    to real got offsets.  */
6632
6633 static boolean
6634 elf_gc_allocate_got_offsets (h, offarg)
6635      struct elf_link_hash_entry *h;
6636      PTR offarg;
6637 {
6638   bfd_vma *off = (bfd_vma *) offarg;
6639
6640   if (h->got.refcount > 0)
6641     {
6642       h->got.offset = off[0];
6643       off[0] += ARCH_SIZE / 8;
6644     }
6645   else
6646     h->got.offset = (bfd_vma) -1;
6647
6648   return true;
6649 }
6650
6651 /* Many folk need no more in the way of final link than this, once
6652    got entry reference counting is enabled.  */
6653
6654 boolean
6655 elf_gc_common_final_link (abfd, info)
6656      bfd *abfd;
6657      struct bfd_link_info *info;
6658 {
6659   if (!elf_gc_common_finalize_got_offsets (abfd, info))
6660     return false;
6661
6662   /* Invoke the regular ELF backend linker to do all the work.  */
6663   return elf_bfd_final_link (abfd, info);
6664 }
6665
6666 /* This function will be called though elf_link_hash_traverse to store
6667    all hash value of the exported symbols in an array.  */
6668
6669 static boolean
6670 elf_collect_hash_codes (h, data)
6671      struct elf_link_hash_entry *h;
6672      PTR data;
6673 {
6674   unsigned long **valuep = (unsigned long **) data;
6675   const char *name;
6676   char *p;
6677   unsigned long ha;
6678   char *alc = NULL;
6679
6680   /* Ignore indirect symbols.  These are added by the versioning code.  */
6681   if (h->dynindx == -1)
6682     return true;
6683
6684   name = h->root.root.string;
6685   p = strchr (name, ELF_VER_CHR);
6686   if (p != NULL)
6687     {
6688       alc = bfd_malloc (p - name + 1);
6689       memcpy (alc, name, p - name);
6690       alc[p - name] = '\0';
6691       name = alc;
6692     }
6693
6694   /* Compute the hash value.  */
6695   ha = bfd_elf_hash (name);
6696
6697   /* Store the found hash value in the array given as the argument.  */
6698   *(*valuep)++ = ha;
6699
6700   /* And store it in the struct so that we can put it in the hash table
6701      later.  */
6702   h->elf_hash_value = ha;
6703
6704   if (alc != NULL)
6705     free (alc);
6706
6707   return true;
6708 }