bfd/elflink.h

   1 /* ELF linker support.
   2    Copyright 1995 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 static boolean elf_link_add_object_symbols
  23   PARAMS ((bfd *, struct bfd_link_info *));
  24 static boolean elf_link_add_archive_symbols
  25   PARAMS ((bfd *, struct bfd_link_info *));
  26 static Elf_Internal_Rela *elf_link_read_relocs
  27   PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, boolean));
  28 static boolean elf_export_symbol
  29   PARAMS ((struct elf_link_hash_entry *, PTR));
  30 static boolean elf_adjust_dynamic_symbol
  31   PARAMS ((struct elf_link_hash_entry *, PTR));
  32
  33 /* This struct is used to pass information to routines called via
  34    elf_link_hash_traverse which must return failure.  */
  35
  36 struct elf_info_failed
  37 {
  38   boolean failed;
  39   struct bfd_link_info *info;
  40 };
  41
  42 /* Given an ELF BFD, add symbols to the global hash table as
  43    appropriate.  */
  44
  45 boolean
  46 elf_bfd_link_add_symbols (abfd, info)
  47      bfd *abfd;
  48      struct bfd_link_info *info;
  49 {
  50   switch (bfd_get_format (abfd))
  51     {
  52     case bfd_object:
  53       return elf_link_add_object_symbols (abfd, info);
  54     case bfd_archive:
  55       return elf_link_add_archive_symbols (abfd, info);
  56     default:
  57       bfd_set_error (bfd_error_wrong_format);
  58       return false;
  59     }
  60 }
  61
  62 /* Add symbols from an ELF archive file to the linker hash table.  We
  63    don't use _bfd_generic_link_add_archive_symbols because of a
  64    problem which arises on UnixWare.  The UnixWare libc.so is an
  65    archive which includes an entry libc.so.1 which defines a bunch of
  66    symbols.  The libc.so archive also includes a number of other
  67    object files, which also define symbols, some of which are the same
  68    as those defined in libc.so.1.  Correct linking requires that we
  69    consider each object file in turn, and include it if it defines any
  70    symbols we need.  _bfd_generic_link_add_archive_symbols does not do
  71    this; it looks through the list of undefined symbols, and includes
  72    any object file which defines them.  When this algorithm is used on
  73    UnixWare, it winds up pulling in libc.so.1 early and defining a
  74    bunch of symbols.  This means that some of the other objects in the
  75    archive are not included in the link, which is incorrect since they
  76    precede libc.so.1 in the archive.
  77
  78    Fortunately, ELF archive handling is simpler than that done by
  79    _bfd_generic_link_add_archive_symbols, which has to allow for a.out
  80    oddities.  In ELF, if we find a symbol in the archive map, and the
  81    symbol is currently undefined, we know that we must pull in that
  82    object file.
  83
  84    Unfortunately, we do have to make multiple passes over the symbol
  85    table until nothing further is resolved.  */
  86
  87 static boolean
  88 elf_link_add_archive_symbols (abfd, info)
  89      bfd *abfd;
  90      struct bfd_link_info *info;
  91 {
  92   symindex c;
  93   boolean *defined = NULL;
  94   boolean *included = NULL;
  95   carsym *symdefs;
  96   boolean loop;
  97
  98   if (! bfd_has_map (abfd))
  99     {
 100       /* An empty archive is a special case.  */
 101       if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
 102         return true;
 103       bfd_set_error (bfd_error_no_armap);
 104       return false;
 105     }
 106
 107   /* Keep track of all symbols we know to be already defined, and all
 108      files we know to be already included.  This is to speed up the
 109      second and subsequent passes.  */
 110   c = bfd_ardata (abfd)->symdef_count;
 111   if (c == 0)
 112     return true;
 113   defined = (boolean *) malloc (c * sizeof (boolean));
 114   included = (boolean *) malloc (c * sizeof (boolean));
 115   if (defined == (boolean *) NULL || included == (boolean *) NULL)
 116     {
 117       bfd_set_error (bfd_error_no_memory);
 118       goto error_return;
 119     }
 120   memset (defined, 0, c * sizeof (boolean));
 121   memset (included, 0, c * sizeof (boolean));
 122
 123   symdefs = bfd_ardata (abfd)->symdefs;
 124
 125   do
 126     {
 127       file_ptr last;
 128       symindex i;
 129       carsym *symdef;
 130       carsym *symdefend;
 131
 132       loop = false;
 133       last = -1;
 134
 135       symdef = symdefs;
 136       symdefend = symdef + c;
 137       for (i = 0; symdef < symdefend; symdef++, i++)
 138         {
 139           struct elf_link_hash_entry *h;
 140           bfd *element;
 141           struct bfd_link_hash_entry *undefs_tail;
 142           symindex mark;
 143
 144           if (defined[i] || included[i])
 145             continue;
 146           if (symdef->file_offset == last)
 147             {
 148               included[i] = true;
 149               continue;
 150             }
 151
 152           h = elf_link_hash_lookup (elf_hash_table (info), symdef->name,
 153                                     false, false, false);
 154           if (h == (struct elf_link_hash_entry *) NULL)
 155             continue;
 156           if (h->root.type != bfd_link_hash_undefined)
 157             {
 158               if (h->root.type != bfd_link_hash_undefweak)
 159                 defined[i] = true;
 160               continue;
 161             }
 162
 163           /* We need to include this archive member.  */
 164
 165           element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
 166           if (element == (bfd *) NULL)
 167             goto error_return;
 168
 169           if (! bfd_check_format (element, bfd_object))
 170             goto error_return;
 171
 172           /* Doublecheck that we have not included this object
 173              already--it should be impossible, but there may be
 174              something wrong with the archive.  */
 175           if (element->archive_pass != 0)
 176             {
 177               bfd_set_error (bfd_error_bad_value);
 178               goto error_return;
 179             }
 180           element->archive_pass = 1;
 181
 182           undefs_tail = info->hash->undefs_tail;
 183
 184           if (! (*info->callbacks->add_archive_element) (info, element,
 185                                                          symdef->name))
 186             goto error_return;
 187           if (! elf_link_add_object_symbols (element, info))
 188             goto error_return;
 189
 190           /* If there are any new undefined symbols, we need to make
 191              another pass through the archive in order to see whether
 192              they can be defined.  FIXME: This isn't perfect, because
 193              common symbols wind up on undefs_tail and because an
 194              undefined symbol which is defined later on in this pass
 195              does not require another pass.  This isn't a bug, but it
 196              does make the code less efficient than it could be.  */
 197           if (undefs_tail != info->hash->undefs_tail)
 198             loop = true;
 199
 200           /* Look backward to mark all symbols from this object file
 201              which we have already seen in this pass.  */
 202           mark = i;
 203           do
 204             {
 205               included[mark] = true;
 206               if (mark == 0)
 207                 break;
 208               --mark;
 209             }
 210           while (symdefs[mark].file_offset == symdef->file_offset);
 211
 212           /* We mark subsequent symbols from this object file as we go
 213              on through the loop.  */
 214           last = symdef->file_offset;
 215         }
 216     }
 217   while (loop);
 218
 219   free (defined);
 220   free (included);
 221
 222   return true;
 223
 224  error_return:
 225   if (defined != (boolean *) NULL)
 226     free (defined);
 227   if (included != (boolean *) NULL)
 228     free (included);
 229   return false;
 230 }
 231
 232 /* Add symbols from an ELF object file to the linker hash table.  */
 233
 234 static boolean
 235 elf_link_add_object_symbols (abfd, info)
 236      bfd *abfd;
 237      struct bfd_link_info *info;
 238 {
 239   boolean (*add_symbol_hook) PARAMS ((bfd *, struct bfd_link_info *,
 240                                       const Elf_Internal_Sym *,
 241                                       const char **, flagword *,
 242                                       asection **, bfd_vma *));
 243   boolean (*check_relocs) PARAMS ((bfd *, struct bfd_link_info *,
 244                                    asection *, const Elf_Internal_Rela *));
 245   boolean collect;
 246   Elf_Internal_Shdr *hdr;
 247   size_t symcount;
 248   size_t extsymcount;
 249   size_t extsymoff;
 250   Elf_External_Sym *buf = NULL;
 251   struct elf_link_hash_entry **sym_hash;
 252   boolean dynamic;
 253   Elf_External_Dyn *dynbuf = NULL;
 254   struct elf_link_hash_entry *weaks;
 255   Elf_External_Sym *esym;
 256   Elf_External_Sym *esymend;
 257
 258   add_symbol_hook = get_elf_backend_data (abfd)->elf_add_symbol_hook;
 259   collect = get_elf_backend_data (abfd)->collect;
 260
 261   /* As a GNU extension, any input sections which are named
 262      .gnu.warning.SYMBOL are treated as warning symbols for the given
 263      symbol.  This differs from .gnu.warning sections, which generate
 264      warnings when they are included in an output file.  */
 265   if (! info->shared)
 266     {
 267       asection *s;
 268
 269       for (s = abfd->sections; s != NULL; s = s->next)
 270         {
 271           const char *name;
 272
 273           name = bfd_get_section_name (abfd, s);
 274           if (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0)
 275             {
 276               char *msg;
 277               bfd_size_type sz;
 278
 279               sz = bfd_section_size (abfd, s);
 280               msg = (char *) bfd_alloc (abfd, sz);
 281               if (msg == NULL)
 282                 {
 283                   bfd_set_error (bfd_error_no_memory);
 284                   goto error_return;
 285                 }
 286
 287               if (! bfd_get_section_contents (abfd, s, msg, (file_ptr) 0, sz))
 288                 goto error_return;
 289
 290               if (! (_bfd_generic_link_add_one_symbol
 291                      (info, abfd,
 292                       name + sizeof ".gnu.warning." - 1,
 293                       BSF_WARNING, s, (bfd_vma) 0, msg, false, collect,
 294                       (struct bfd_link_hash_entry **) NULL)))
 295                 goto error_return;
 296
 297               if (! info->relocateable)
 298                 {
 299                   /* Clobber the section size so that the warning does
 300                      not get copied into the output file.  */
 301                   s->_raw_size = 0;
 302                 }
 303             }
 304         }
 305     }
 306
 307   /* A stripped shared library might only have a dynamic symbol table,
 308      not a regular symbol table.  In that case we can still go ahead
 309      and link using the dynamic symbol table.  */
 310   if (elf_onesymtab (abfd) == 0
 311       && elf_dynsymtab (abfd) != 0)
 312     {
 313       elf_onesymtab (abfd) = elf_dynsymtab (abfd);
 314       elf_tdata (abfd)->symtab_hdr = elf_tdata (abfd)->dynsymtab_hdr;
 315     }
 316
 317   hdr = &elf_tdata (abfd)->symtab_hdr;
 318   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
 319
 320   /* The sh_info field of the symtab header tells us where the
 321      external symbols start.  We don't care about the local symbols at
 322      this point.  */
 323   if (elf_bad_symtab (abfd))
 324     {
 325       extsymcount = symcount;
 326       extsymoff = 0;
 327     }
 328   else
 329     {
 330       extsymcount = symcount - hdr->sh_info;
 331       extsymoff = hdr->sh_info;
 332     }
 333
 334   buf = (Elf_External_Sym *) malloc (extsymcount * sizeof (Elf_External_Sym));
 335   if (buf == NULL && extsymcount != 0)
 336     {
 337       bfd_set_error (bfd_error_no_memory);
 338       goto error_return;
 339     }
 340
 341   /* We store a pointer to the hash table entry for each external
 342      symbol.  */
 343   sym_hash = ((struct elf_link_hash_entry **)
 344               bfd_alloc (abfd,
 345                          extsymcount * sizeof (struct elf_link_hash_entry *)));
 346   if (sym_hash == NULL)
 347     {
 348       bfd_set_error (bfd_error_no_memory);
 349       goto error_return;
 350     }
 351   elf_sym_hashes (abfd) = sym_hash;
 352
 353   if (elf_elfheader (abfd)->e_type != ET_DYN)
 354     {
 355       dynamic = false;
 356
 357       /* If we are creating a shared library, create all the dynamic
 358          sections immediately.  We need to attach them to something,
 359          so we attach them to this BFD, provided it is the right
 360          format.  FIXME: If there are no input BFD's of the same
 361          format as the output, we can't make a shared library.  */
 362       if (info->shared
 363           && ! elf_hash_table (info)->dynamic_sections_created
 364           && abfd->xvec == info->hash->creator)
 365         {
 366           if (! elf_link_create_dynamic_sections (abfd, info))
 367             goto error_return;
 368         }
 369     }
 370   else
 371     {
 372       asection *s;
 373       boolean add_needed;
 374       const char *name;
 375       bfd_size_type oldsize;
 376       bfd_size_type strindex;
 377
 378       dynamic = true;
 379
 380       /* You can't use -r against a dynamic object.  Also, there's no
 381          hope of using a dynamic object which does not exactly match
 382          the format of the output file.  */
 383       if (info->relocateable
 384           || info->hash->creator != abfd->xvec)
 385         {
 386           bfd_set_error (bfd_error_invalid_operation);
 387           goto error_return;
 388         }
 389
 390       /* Find the name to use in a DT_NEEDED entry that refers to this
 391          object.  If the object has a DT_SONAME entry, we use it.
 392          Otherwise, if the generic linker stuck something in
 393          elf_dt_needed_name, we use that.  Otherwise, we just use the
 394          file name.  If the generic linker put a null string into
 395          elf_dt_needed_name, we don't make a DT_NEEDED entry at all,
 396          even if there is a DT_SONAME entry.  */
 397       add_needed = true;
 398       name = bfd_get_filename (abfd);
 399       if (elf_dt_needed_name (abfd) != NULL)
 400         {
 401           name = elf_dt_needed_name (abfd);
 402           if (*name == '\0')
 403             add_needed = false;
 404         }
 405       s = bfd_get_section_by_name (abfd, ".dynamic");
 406       if (s != NULL)
 407         {
 408           Elf_External_Dyn *extdyn;
 409           Elf_External_Dyn *extdynend;
 410           int elfsec;
 411           unsigned long link;
 412
 413           dynbuf = (Elf_External_Dyn *) malloc ((size_t) s->_raw_size);
 414           if (dynbuf == NULL)
 415             {
 416               bfd_set_error (bfd_error_no_memory);
 417               goto error_return;
 418             }
 419
 420           if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
 421                                           (file_ptr) 0, s->_raw_size))
 422             goto error_return;
 423
 424           elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
 425           if (elfsec == -1)
 426             goto error_return;
 427           link = elf_elfsections (abfd)[elfsec]->sh_link;
 428
 429           extdyn = dynbuf;
 430           extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
 431           for (; extdyn < extdynend; extdyn++)
 432             {
 433               Elf_Internal_Dyn dyn;
 434
 435               elf_swap_dyn_in (abfd, extdyn, &dyn);
 436               if (add_needed && dyn.d_tag == DT_SONAME)
 437                 {
 438                   name = bfd_elf_string_from_elf_section (abfd, link,
 439                                                           dyn.d_un.d_val);
 440                   if (name == NULL)
 441                     goto error_return;
 442                 }
 443               if (dyn.d_tag == DT_NEEDED)
 444                 {
 445                   struct bfd_elf_link_needed_list *n, **pn;
 446                   char *fnm, *anm;
 447
 448                   n = (struct bfd_elf_link_needed_list *)
 449                     bfd_alloc (abfd,
 450                                sizeof (struct bfd_elf_link_needed_list));
 451                   fnm = bfd_elf_string_from_elf_section (abfd, link,
 452                                                          dyn.d_un.d_val);
 453                   if (n == NULL || fnm == NULL)
 454                     goto error_return;
 455                   anm = bfd_alloc (abfd, strlen (fnm) + 1);
 456                   if (anm == NULL)
 457                     goto error_return;
 458                   strcpy (anm, fnm);
 459                   n->name = anm;
 460                   n->by = abfd;
 461                   n->next = NULL;
 462                   for (pn = &elf_hash_table (info)->needed;
 463                        *pn != NULL;
 464                        pn = &(*pn)->next)
 465                     ;
 466                   *pn = n;
 467                 }
 468             }
 469
 470           free (dynbuf);
 471           dynbuf = NULL;
 472         }
 473
 474       /* We do not want to include any of the sections in a dynamic
 475          object in the output file.  We hack by simply clobbering the
 476          list of sections in the BFD.  This could be handled more
 477          cleanly by, say, a new section flag; the existing
 478          SEC_NEVER_LOAD flag is not the one we want, because that one
 479          still implies that the section takes up space in the output
 480          file.  */
 481       abfd->sections = NULL;
 482
 483       /* If this is the first dynamic object found in the link, create
 484          the special sections required for dynamic linking.  */
 485       if (! elf_hash_table (info)->dynamic_sections_created)
 486         {
 487           if (! elf_link_create_dynamic_sections (abfd, info))
 488             goto error_return;
 489         }
 490
 491       if (add_needed)
 492         {
 493           /* Add a DT_NEEDED entry for this dynamic object.  */
 494           oldsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
 495           strindex = _bfd_stringtab_add (elf_hash_table (info)->dynstr, name,
 496                                          true, false);
 497           if (strindex == (bfd_size_type) -1)
 498             goto error_return;
 499
 500           if (oldsize == _bfd_stringtab_size (elf_hash_table (info)->dynstr))
 501             {
 502               asection *sdyn;
 503               Elf_External_Dyn *dyncon, *dynconend;
 504
 505               /* The hash table size did not change, which means that
 506                  the dynamic object name was already entered.  If we
 507                  have already included this dynamic object in the
 508                  link, just ignore it.  There is no reason to include
 509                  a particular dynamic object more than once.  */
 510               sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj,
 511                                               ".dynamic");
 512               BFD_ASSERT (sdyn != NULL);
 513
 514               dyncon = (Elf_External_Dyn *) sdyn->contents;
 515               dynconend = (Elf_External_Dyn *) (sdyn->contents +
 516                                                 sdyn->_raw_size);
 517               for (; dyncon < dynconend; dyncon++)
 518                 {
 519                   Elf_Internal_Dyn dyn;
 520
 521                   elf_swap_dyn_in (elf_hash_table (info)->dynobj, dyncon,
 522                                    &dyn);
 523                   if (dyn.d_tag == DT_NEEDED
 524                       && dyn.d_un.d_val == strindex)
 525                     {
 526                       if (buf != NULL)
 527                         free (buf);
 528                       return true;
 529                     }
 530                 }
 531             }
 532
 533           if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
 534             goto error_return;
 535         }
 536     }
 537
 538   if (bfd_seek (abfd,
 539                 hdr->sh_offset + extsymoff * sizeof (Elf_External_Sym),
 540                 SEEK_SET) != 0
 541       || (bfd_read ((PTR) buf, sizeof (Elf_External_Sym), extsymcount, abfd)
 542           != extsymcount * sizeof (Elf_External_Sym)))
 543     goto error_return;
 544
 545   weaks = NULL;
 546
 547   esymend = buf + extsymcount;
 548   for (esym = buf; esym < esymend; esym++, sym_hash++)
 549     {
 550       Elf_Internal_Sym sym;
 551       int bind;
 552       bfd_vma value;
 553       asection *sec;
 554       flagword flags;
 555       const char *name;
 556       struct elf_link_hash_entry *h;
 557       boolean definition;
 558       boolean new_weakdef;
 559
 560       elf_swap_symbol_in (abfd, esym, &sym);
 561
 562       flags = BSF_NO_FLAGS;
 563       sec = NULL;
 564       value = sym.st_value;
 565       *sym_hash = NULL;
 566
 567       bind = ELF_ST_BIND (sym.st_info);
 568       if (bind == STB_LOCAL)
 569         {
 570           /* This should be impossible, since ELF requires that all
 571              global symbols follow all local symbols, and that sh_info
 572              point to the first global symbol.  Unfortunatealy, Irix 5
 573              screws this up.  */
 574           continue;
 575         }
 576       else if (bind == STB_GLOBAL)
 577         {
 578           if (sym.st_shndx != SHN_UNDEF
 579               && sym.st_shndx != SHN_COMMON)
 580             flags = BSF_GLOBAL;
 581           else
 582             flags = 0;
 583         }
 584       else if (bind == STB_WEAK)
 585         flags = BSF_WEAK;
 586       else
 587         {
 588           /* Leave it up to the processor backend.  */
 589         }
 590
 591       if (sym.st_shndx == SHN_UNDEF)
 592         sec = bfd_und_section_ptr;
 593       else if (sym.st_shndx > 0 && sym.st_shndx < SHN_LORESERVE)
 594         {
 595           sec = section_from_elf_index (abfd, sym.st_shndx);
 596           if (sec != NULL)
 597             value -= sec->vma;
 598           else
 599             sec = bfd_abs_section_ptr;
 600         }
 601       else if (sym.st_shndx == SHN_ABS)
 602         sec = bfd_abs_section_ptr;
 603       else if (sym.st_shndx == SHN_COMMON)
 604         {
 605           sec = bfd_com_section_ptr;
 606           /* What ELF calls the size we call the value.  What ELF
 607              calls the value we call the alignment.  */
 608           value = sym.st_size;
 609         }
 610       else
 611         {
 612           /* Leave it up to the processor backend.  */
 613         }
 614
 615       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, sym.st_name);
 616       if (name == (const char *) NULL)
 617         goto error_return;
 618
 619       if (add_symbol_hook)
 620         {
 621           if (! (*add_symbol_hook) (abfd, info, &sym, &name, &flags, &sec,
 622                                     &value))
 623             goto error_return;
 624
 625           /* The hook function sets the name to NULL if this symbol
 626              should be skipped for some reason.  */
 627           if (name == (const char *) NULL)
 628             continue;
 629         }
 630
 631       /* Sanity check that all possibilities were handled.  */
 632       if (sec == (asection *) NULL)
 633         {
 634           bfd_set_error (bfd_error_bad_value);
 635           goto error_return;
 636         }
 637
 638       if (bfd_is_und_section (sec)
 639           || bfd_is_com_section (sec))
 640         definition = false;
 641       else
 642         definition = true;
 643
 644       if (info->hash->creator->flavour == bfd_target_elf_flavour)
 645         {
 646           /* We need to look up the symbol now in order to get some of
 647              the dynamic object handling right.  We pass the hash
 648              table entry in to _bfd_generic_link_add_one_symbol so
 649              that it does not have to look it up again.  */
 650           h = elf_link_hash_lookup (elf_hash_table (info), name,
 651                                     true, false, false);
 652           if (h == NULL)
 653             goto error_return;
 654           *sym_hash = h;
 655
 656           while (h->root.type == bfd_link_hash_indirect
 657                  || h->root.type == bfd_link_hash_warning)
 658             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 659
 660           /* If we are looking at a dynamic object, and this is a
 661              definition, we need to see if it has already been defined
 662              by some other object.  If it has, we want to use the
 663              existing definition, and we do not want to report a
 664              multiple symbol definition error; we do this by
 665              clobbering sec to be bfd_und_section_ptr.  */
 666           if (dynamic && definition)
 667             {
 668               if (h->root.type == bfd_link_hash_defined
 669                   || h->root.type == bfd_link_hash_defweak)
 670                 sec = bfd_und_section_ptr;
 671             }
 672
 673           /* Similarly, if we are not looking at a dynamic object, and
 674              we have a definition, we want to override any definition
 675              we may have from a dynamic object.  Symbols from regular
 676              files always take precedence over symbols from dynamic
 677              objects, even if they are defined after the dynamic
 678              object in the link.  */
 679           if (! dynamic
 680               && definition
 681               && (h->root.type == bfd_link_hash_defined
 682                   || h->root.type == bfd_link_hash_defweak)
 683               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 684               && (bfd_get_flavour (h->root.u.def.section->owner)
 685                   == bfd_target_elf_flavour)
 686               && (elf_elfheader (h->root.u.def.section->owner)->e_type
 687                   == ET_DYN))
 688             {
 689               /* Change the hash table entry to undefined, and let
 690                  _bfd_generic_link_add_one_symbol do the right thing
 691                  with the new definition.  */
 692               h->root.type = bfd_link_hash_undefined;
 693               h->root.u.undef.abfd = h->root.u.def.section->owner;
 694             }
 695         }
 696
 697       if (! (_bfd_generic_link_add_one_symbol
 698              (info, abfd, name, flags, sec, value, (const char *) NULL,
 699               false, collect, (struct bfd_link_hash_entry **) sym_hash)))
 700         goto error_return;
 701
 702       h = *sym_hash;
 703       while (h->root.type == bfd_link_hash_indirect
 704              || h->root.type == bfd_link_hash_warning)
 705         h = (struct elf_link_hash_entry *) h->root.u.i.link;
 706       *sym_hash = h;
 707
 708       new_weakdef = false;
 709       if (dynamic
 710           && definition
 711           && (flags & BSF_WEAK) != 0
 712           && ELF_ST_TYPE (sym.st_info) != STT_FUNC
 713           && info->hash->creator->flavour == bfd_target_elf_flavour
 714           && h->weakdef == NULL)
 715         {
 716           /* Keep a list of all weak defined non function symbols from
 717              a dynamic object, using the weakdef field.  Later in this
 718              function we will set the weakdef field to the correct
 719              value.  We only put non-function symbols from dynamic
 720              objects on this list, because that happens to be the only
 721              time we need to know the normal symbol corresponding to a
 722              weak symbol, and the information is time consuming to
 723              figure out.  If the weakdef field is not already NULL,
 724              then this symbol was already defined by some previous
 725              dynamic object, and we will be using that previous
 726              definition anyhow.  */
 727
 728           h->weakdef = weaks;
 729           weaks = h;
 730           new_weakdef = true;
 731         }
 732
 733       /* Get the alignment of a common symbol.  */
 734       if (sym.st_shndx == SHN_COMMON
 735           && h->root.type == bfd_link_hash_common)
 736         h->root.u.c.p->alignment_power = bfd_log2 (sym.st_value);
 737
 738       if (info->hash->creator->flavour == bfd_target_elf_flavour)
 739         {
 740           int old_flags;
 741           boolean dynsym;
 742           int new_flag;
 743
 744           /* Remember the symbol size and type.  */
 745           if (sym.st_size != 0)
 746             {
 747               /* FIXME: We should probably somehow give a warning if
 748                  the symbol size changes.  */
 749               h->size = sym.st_size;
 750             }
 751           if (ELF_ST_TYPE (sym.st_info) != STT_NOTYPE)
 752             {
 753               /* FIXME: We should probably somehow give a warning if
 754                  the symbol type changes.  */
 755               h->type = ELF_ST_TYPE (sym.st_info);
 756             }
 757
 758           /* Set a flag in the hash table entry indicating the type of
 759              reference or definition we just found.  Keep a count of
 760              the number of dynamic symbols we find.  A dynamic symbol
 761              is one which is referenced or defined by both a regular
 762              object and a shared object, or one which is referenced or
 763              defined by more than one shared object.  */
 764           old_flags = h->elf_link_hash_flags;
 765           dynsym = false;
 766           if (! dynamic)
 767             {
 768               if (! definition)
 769                 new_flag = ELF_LINK_HASH_REF_REGULAR;
 770               else
 771                 new_flag = ELF_LINK_HASH_DEF_REGULAR;
 772               if (info->shared
 773                   || (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
 774                                    | ELF_LINK_HASH_REF_DYNAMIC)) != 0)
 775                 dynsym = true;
 776             }
 777           else
 778             {
 779               if (! definition)
 780                 new_flag = ELF_LINK_HASH_REF_DYNAMIC;
 781               else
 782                 new_flag = ELF_LINK_HASH_DEF_DYNAMIC;
 783               if ((old_flags & new_flag) != 0
 784                   || (old_flags & (ELF_LINK_HASH_DEF_REGULAR
 785                                    | ELF_LINK_HASH_REF_REGULAR)) != 0
 786                   || (h->weakdef != NULL
 787                       && (old_flags & (ELF_LINK_HASH_DEF_DYNAMIC
 788                                        | ELF_LINK_HASH_REF_DYNAMIC)) != 0))
 789                 dynsym = true;
 790             }
 791
 792           h->elf_link_hash_flags |= new_flag;
 793           if (dynsym && h->dynindx == -1)
 794             {
 795               if (! _bfd_elf_link_record_dynamic_symbol (info, h))
 796                 goto error_return;
 797               if (h->weakdef != NULL
 798                   && ! new_weakdef
 799                   && h->weakdef->dynindx == -1)
 800                 {
 801                   if (! _bfd_elf_link_record_dynamic_symbol (info,
 802                                                              h->weakdef))
 803                     goto error_return;
 804                 }
 805             }
 806         }
 807     }
 808
 809   /* Now set the weakdefs field correctly for all the weak defined
 810      symbols we found.  The only way to do this is to search all the
 811      symbols.  Since we only need the information for non functions in
 812      dynamic objects, that's the only time we actually put anything on
 813      the list WEAKS.  We need this information so that if a regular
 814      object refers to a symbol defined weakly in a dynamic object, the
 815      real symbol in the dynamic object is also put in the dynamic
 816      symbols; we also must arrange for both symbols to point to the
 817      same memory location.  We could handle the general case of symbol
 818      aliasing, but a general symbol alias can only be generated in
 819      assembler code, handling it correctly would be very time
 820      consuming, and other ELF linkers don't handle general aliasing
 821      either.  */
 822   while (weaks != NULL)
 823     {
 824       struct elf_link_hash_entry *hlook;
 825       asection *slook;
 826       bfd_vma vlook;
 827       struct elf_link_hash_entry **hpp;
 828       struct elf_link_hash_entry **hppend;
 829
 830       hlook = weaks;
 831       weaks = hlook->weakdef;
 832       hlook->weakdef = NULL;
 833
 834       BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
 835                   || hlook->root.type == bfd_link_hash_defweak
 836                   || hlook->root.type == bfd_link_hash_common
 837                   || hlook->root.type == bfd_link_hash_indirect);
 838       slook = hlook->root.u.def.section;
 839       vlook = hlook->root.u.def.value;
 840
 841       hpp = elf_sym_hashes (abfd);
 842       hppend = hpp + extsymcount;
 843       for (; hpp < hppend; hpp++)
 844         {
 845           struct elf_link_hash_entry *h;
 846
 847           h = *hpp;
 848           if (h != NULL && h != hlook
 849               && (h->root.type == bfd_link_hash_defined
 850                   || h->root.type == bfd_link_hash_defweak)
 851               && h->root.u.def.section == slook
 852               && h->root.u.def.value == vlook)
 853             {
 854               hlook->weakdef = h;
 855
 856               /* If the weak definition is in the list of dynamic
 857                  symbols, make sure the real definition is put there
 858                  as well.  */
 859               if (hlook->dynindx != -1
 860                   && h->dynindx == -1)
 861                 {
 862                   if (! _bfd_elf_link_record_dynamic_symbol (info, h))
 863                     goto error_return;
 864                 }
 865
 866               break;
 867             }
 868         }
 869     }
 870
 871   if (buf != NULL)
 872     {
 873       free (buf);
 874       buf = NULL;
 875     }
 876
 877   /* If this object is the same format as the output object, and it is
 878      not a shared library, then let the backend look through the
 879      relocs.
 880
 881      This is required to build global offset table entries and to
 882      arrange for dynamic relocs.  It is not required for the
 883      particular common case of linking non PIC code, even when linking
 884      against shared libraries, but unfortunately there is no way of
 885      knowing whether an object file has been compiled PIC or not.
 886      Looking through the relocs is not particularly time consuming.
 887      The problem is that we must either (1) keep the relocs in memory,
 888      which causes the linker to require additional runtime memory or
 889      (2) read the relocs twice from the input file, which wastes time.
 890      This would be a good case for using mmap.
 891
 892      I have no idea how to handle linking PIC code into a file of a
 893      different format.  It probably can't be done.  */
 894   check_relocs = get_elf_backend_data (abfd)->check_relocs;
 895   if (! dynamic
 896       && abfd->xvec == info->hash->creator
 897       && check_relocs != NULL)
 898     {
 899       asection *o;
 900
 901       for (o = abfd->sections; o != NULL; o = o->next)
 902         {
 903           Elf_Internal_Rela *internal_relocs;
 904           boolean ok;
 905
 906           if ((o->flags & SEC_RELOC) == 0
 907               || o->reloc_count == 0)
 908             continue;
 909
 910           /* I believe we can ignore the relocs for any section which
 911              does not form part of the final process image, such as a
 912              debugging section.  */
 913           if ((o->flags & SEC_ALLOC) == 0)
 914             continue;
 915
 916           internal_relocs = elf_link_read_relocs (abfd, o, (PTR) NULL,
 917                                                   (Elf_Internal_Rela *) NULL,
 918                                                   info->keep_memory);
 919           if (internal_relocs == NULL)
 920             goto error_return;
 921
 922           ok = (*check_relocs) (abfd, info, o, internal_relocs);
 923
 924           if (! info->keep_memory)
 925             free (internal_relocs);
 926
 927           if (! ok)
 928             goto error_return;
 929         }
 930     }
 931
 932   return true;
 933
 934  error_return:
 935   if (buf != NULL)
 936     free (buf);
 937   if (dynbuf != NULL)
 938     free (dynbuf);
 939   return false;
 940 }
 941
 942 /* Create some sections which will be filled in with dynamic linking
 943    information.  ABFD is an input file which requires dynamic sections
 944    to be created.  The dynamic sections take up virtual memory space
 945    when the final executable is run, so we need to create them before
 946    addresses are assigned to the output sections.  We work out the
 947    actual contents and size of these sections later.  */
 948
 949 boolean
 950 elf_link_create_dynamic_sections (abfd, info)
 951      bfd *abfd;
 952      struct bfd_link_info *info;
 953 {
 954   flagword flags;
 955   register asection *s;
 956   struct elf_link_hash_entry *h;
 957   struct elf_backend_data *bed;
 958
 959   if (elf_hash_table (info)->dynamic_sections_created)
 960     return true;
 961
 962   /* Make sure that all dynamic sections use the same input BFD.  */
 963   if (elf_hash_table (info)->dynobj == NULL)
 964     elf_hash_table (info)->dynobj = abfd;
 965   else
 966     abfd = elf_hash_table (info)->dynobj;
 967
 968   /* Note that we set the SEC_IN_MEMORY flag for all of these
 969      sections.  */
 970   flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
 971
 972   /* A dynamically linked executable has a .interp section, but a
 973      shared library does not.  */
 974   if (! info->shared)
 975     {
 976       s = bfd_make_section (abfd, ".interp");
 977       if (s == NULL
 978           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
 979         return false;
 980     }
 981
 982   s = bfd_make_section (abfd, ".dynsym");
 983   if (s == NULL
 984       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 985       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
 986     return false;
 987
 988   s = bfd_make_section (abfd, ".dynstr");
 989   if (s == NULL
 990       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY))
 991     return false;
 992
 993   /* Create a strtab to hold the dynamic symbol names.  */
 994   if (elf_hash_table (info)->dynstr == NULL)
 995     {
 996       elf_hash_table (info)->dynstr = elf_stringtab_init ();
 997       if (elf_hash_table (info)->dynstr == NULL)
 998         return false;
 999     }
1000
1001   s = bfd_make_section (abfd, ".dynamic");
1002   if (s == NULL
1003       || ! bfd_set_section_flags (abfd, s, flags)
1004       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1005     return false;
1006
1007   /* The special symbol _DYNAMIC is always set to the start of the
1008      .dynamic section.  This call occurs before we have processed the
1009      symbols for any dynamic object, so we don't have to worry about
1010      overriding a dynamic definition.  We could set _DYNAMIC in a
1011      linker script, but we only want to define it if we are, in fact,
1012      creating a .dynamic section.  We don't want to define it if there
1013      is no .dynamic section, since on some ELF platforms the start up
1014      code examines it to decide how to initialize the process.  */
1015   h = NULL;
1016   if (! (_bfd_generic_link_add_one_symbol
1017          (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
1018           (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
1019           (struct bfd_link_hash_entry **) &h)))
1020     return false;
1021   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1022   h->type = STT_OBJECT;
1023
1024   if (info->shared
1025       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1026     return false;
1027
1028   s = bfd_make_section (abfd, ".hash");
1029   if (s == NULL
1030       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1031       || ! bfd_set_section_alignment (abfd, s, LOG_FILE_ALIGN))
1032     return false;
1033
1034   /* Let the backend create the rest of the sections.  This lets the
1035      backend set the right flags.  The backend will normally create
1036      the .got and .plt sections.  */
1037   bed = get_elf_backend_data (abfd);
1038   if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
1039     return false;
1040
1041   elf_hash_table (info)->dynamic_sections_created = true;
1042
1043   return true;
1044 }
1045
1046 /* Add an entry to the .dynamic table.  */
1047
1048 boolean
1049 elf_add_dynamic_entry (info, tag, val)
1050      struct bfd_link_info *info;
1051      bfd_vma tag;
1052      bfd_vma val;
1053 {
1054   Elf_Internal_Dyn dyn;
1055   bfd *dynobj;
1056   asection *s;
1057   size_t newsize;
1058   bfd_byte *newcontents;
1059
1060   dynobj = elf_hash_table (info)->dynobj;
1061
1062   s = bfd_get_section_by_name (dynobj, ".dynamic");
1063   BFD_ASSERT (s != NULL);
1064
1065   newsize = s->_raw_size + sizeof (Elf_External_Dyn);
1066   if (s->contents == NULL)
1067     newcontents = (bfd_byte *) malloc (newsize);
1068   else
1069     newcontents = (bfd_byte *) realloc (s->contents, newsize);
1070   if (newcontents == NULL)
1071     {
1072       bfd_set_error (bfd_error_no_memory);
1073       return false;
1074     }
1075
1076   dyn.d_tag = tag;
1077   dyn.d_un.d_val = val;
1078   elf_swap_dyn_out (dynobj, &dyn,
1079                     (Elf_External_Dyn *) (newcontents + s->_raw_size));
1080
1081   s->_raw_size = newsize;
1082   s->contents = newcontents;
1083
1084   return true;
1085 }
1086
1087 /* Read and swap the relocs for a section.  They may have been cached.
1088    If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are not NULL,
1089    they are used as buffers to read into.  They are known to be large
1090    enough.  If the INTERNAL_RELOCS relocs argument is NULL, the return
1091    value is allocated using either malloc or bfd_alloc, according to
1092    the KEEP_MEMORY argument.  */
1093
1094 static Elf_Internal_Rela *
1095 elf_link_read_relocs (abfd, o, external_relocs, internal_relocs, keep_memory)
1096      bfd *abfd;
1097      asection *o;
1098      PTR external_relocs;
1099      Elf_Internal_Rela *internal_relocs;
1100      boolean keep_memory;
1101 {
1102   Elf_Internal_Shdr *rel_hdr;
1103   PTR alloc1 = NULL;
1104   Elf_Internal_Rela *alloc2 = NULL;
1105
1106   if (elf_section_data (o)->relocs != NULL)
1107     return elf_section_data (o)->relocs;
1108
1109   if (o->reloc_count == 0)
1110     return NULL;
1111
1112   rel_hdr = &elf_section_data (o)->rel_hdr;
1113
1114   if (internal_relocs == NULL)
1115     {
1116       size_t size;
1117
1118       size = o->reloc_count * sizeof (Elf_Internal_Rela);
1119       if (keep_memory)
1120         internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
1121       else
1122         internal_relocs = alloc2 = (Elf_Internal_Rela *) malloc (size);
1123       if (internal_relocs == NULL)
1124         {
1125           bfd_set_error (bfd_error_no_memory);
1126           goto error_return;
1127         }
1128     }
1129
1130   if (external_relocs == NULL)
1131     {
1132       alloc1 = (PTR) malloc ((size_t) rel_hdr->sh_size);
1133       if (alloc1 == NULL)
1134         {
1135           bfd_set_error (bfd_error_no_memory);
1136           goto error_return;
1137         }
1138       external_relocs = alloc1;
1139     }
1140
1141   if ((bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0)
1142       || (bfd_read (external_relocs, 1, rel_hdr->sh_size, abfd)
1143           != rel_hdr->sh_size))
1144     goto error_return;
1145
1146   /* Swap in the relocs.  For convenience, we always produce an
1147      Elf_Internal_Rela array; if the relocs are Rel, we set the addend
1148      to 0.  */
1149   if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
1150     {
1151       Elf_External_Rel *erel;
1152       Elf_External_Rel *erelend;
1153       Elf_Internal_Rela *irela;
1154
1155       erel = (Elf_External_Rel *) external_relocs;
1156       erelend = erel + o->reloc_count;
1157       irela = internal_relocs;
1158       for (; erel < erelend; erel++, irela++)
1159         {
1160           Elf_Internal_Rel irel;
1161
1162           elf_swap_reloc_in (abfd, erel, &irel);
1163           irela->r_offset = irel.r_offset;
1164           irela->r_info = irel.r_info;
1165           irela->r_addend = 0;
1166         }
1167     }
1168   else
1169     {
1170       Elf_External_Rela *erela;
1171       Elf_External_Rela *erelaend;
1172       Elf_Internal_Rela *irela;
1173
1174       BFD_ASSERT (rel_hdr->sh_entsize == sizeof (Elf_External_Rela));
1175
1176       erela = (Elf_External_Rela *) external_relocs;
1177       erelaend = erela + o->reloc_count;
1178       irela = internal_relocs;
1179       for (; erela < erelaend; erela++, irela++)
1180         elf_swap_reloca_in (abfd, erela, irela);
1181     }
1182
1183   /* Cache the results for next time, if we can.  */
1184   if (keep_memory)
1185     elf_section_data (o)->relocs = internal_relocs;
1186
1187   if (alloc1 != NULL)
1188     free (alloc1);
1189
1190   /* Don't free alloc2, since if it was allocated we are passing it
1191      back (under the name of internal_relocs).  */
1192
1193   return internal_relocs;
1194
1195  error_return:
1196   if (alloc1 != NULL)
1197     free (alloc1);
1198   if (alloc2 != NULL)
1199     free (alloc2);
1200   return NULL;
1201 }
1202
1203 /* Record an assignment to a symbol made by a linker script.  We need
1204    this in case some dynamic object refers to this symbol.  */
1205
1206 /*ARGSUSED*/
1207 boolean
1208 NAME(bfd_elf,record_link_assignment) (output_bfd, info, name, provide)
1209      bfd *output_bfd;
1210      struct bfd_link_info *info;
1211      const char *name;
1212      boolean provide;
1213 {
1214   struct elf_link_hash_entry *h;
1215
1216   if (info->hash->creator->flavour != bfd_target_elf_flavour)
1217     return true;
1218
1219   h = elf_link_hash_lookup (elf_hash_table (info), name, true, true, false);
1220   if (h == NULL)
1221     return false;
1222
1223   /* If this symbol is being provided by the linker script, and it is
1224      currently defined by a dynamic object, but not by a regular
1225      object, then mark it as undefined so that the generic linker will
1226      force the correct value.  */
1227   if (provide
1228       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1229       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1230     h->root.type = bfd_link_hash_undefined;
1231
1232   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1233   h->type = STT_OBJECT;
1234
1235   if (((h->elf_link_hash_flags & (ELF_LINK_HASH_DEF_DYNAMIC
1236                                   | ELF_LINK_HASH_REF_DYNAMIC)) != 0
1237        || info->shared)
1238       && h->dynindx == -1)
1239     {
1240       if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1241         return false;
1242
1243       /* If this is a weak defined symbol, and we know a corresponding
1244          real symbol from the same dynamic object, make sure the real
1245          symbol is also made into a dynamic symbol.  */
1246       if (h->weakdef != NULL
1247           && h->weakdef->dynindx == -1)
1248         {
1249           if (! _bfd_elf_link_record_dynamic_symbol (info, h->weakdef))
1250             return false;
1251         }
1252     }
1253
1254   return true;
1255 }
1256
1257 /* Array used to determine the number of hash table buckets to use
1258    based on the number of symbols there are.  If there are fewer than
1259    3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
1260    fewer than 37 we use 17 buckets, and so forth.  We never use more
1261    than 521 buckets.  */
1262
1263 static const size_t elf_buckets[] =
1264 {
1265   1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 0
1266 };
1267
1268 /* Set up the sizes and contents of the ELF dynamic sections.  This is
1269    called by the ELF linker emulation before_allocation routine.  We
1270    must set the sizes of the sections before the linker sets the
1271    addresses of the various sections.  */
1272
1273 boolean
1274 NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
1275                                      export_dynamic, info, sinterpptr)
1276      bfd *output_bfd;
1277      const char *soname;
1278      const char *rpath;
1279      boolean export_dynamic;
1280      struct bfd_link_info *info;
1281      asection **sinterpptr;
1282 {
1283   bfd *dynobj;
1284   struct elf_backend_data *bed;
1285
1286   *sinterpptr = NULL;
1287
1288   if (info->hash->creator->flavour != bfd_target_elf_flavour)
1289     return true;
1290
1291   dynobj = elf_hash_table (info)->dynobj;
1292
1293   /* If there were no dynamic objects in the link, there is nothing to
1294      do here.  */
1295   if (dynobj == NULL)
1296     return true;
1297
1298   /* If we are supposed to export all symbols into the dynamic symbol
1299      table (this is not the normal case), then do so.  */
1300   if (export_dynamic)
1301     {
1302       struct elf_info_failed eif;
1303
1304       eif.failed = false;
1305       eif.info = info;
1306       elf_link_hash_traverse (elf_hash_table (info), elf_export_symbol,
1307                               (PTR) &eif);
1308       if (eif.failed)
1309         return false;
1310     }
1311
1312   if (elf_hash_table (info)->dynamic_sections_created)
1313     {
1314       struct elf_info_failed eif;
1315       bfd_size_type strsize;
1316
1317       *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
1318       BFD_ASSERT (*sinterpptr != NULL || info->shared);
1319
1320       if (soname != NULL)
1321         {
1322           bfd_size_type indx;
1323
1324           indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, soname,
1325                                      true, true);
1326           if (indx == (bfd_size_type) -1
1327               || ! elf_add_dynamic_entry (info, DT_SONAME, indx))
1328             return false;
1329         }
1330
1331       if (info->symbolic)
1332         {
1333           if (! elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
1334             return false;
1335         }
1336
1337       if (rpath != NULL)
1338         {
1339           bfd_size_type indx;
1340
1341           indx = _bfd_stringtab_add (elf_hash_table (info)->dynstr, rpath,
1342                                      true, true);
1343           if (indx == (bfd_size_type) -1
1344               || ! elf_add_dynamic_entry (info, DT_RPATH, indx))
1345             return false;
1346         }
1347
1348       /* Find all symbols which were defined in a dynamic object and make
1349          the backend pick a reasonable value for them.  */
1350       eif.failed = false;
1351       eif.info = info;
1352       elf_link_hash_traverse (elf_hash_table (info),
1353                               elf_adjust_dynamic_symbol,
1354                               (PTR) &eif);
1355       if (eif.failed)
1356         return false;
1357
1358       /* Add some entries to the .dynamic section.  We fill in some of the
1359          values later, in elf_bfd_final_link, but we must add the entries
1360          now so that we know the final size of the .dynamic section.  */
1361       if (elf_link_hash_lookup (elf_hash_table (info), "_init", false,
1362                                 false, false) != NULL)
1363         {
1364           if (! elf_add_dynamic_entry (info, DT_INIT, 0))
1365             return false;
1366         }
1367       if (elf_link_hash_lookup (elf_hash_table (info), "_fini", false,
1368                                 false, false) != NULL)
1369         {
1370           if (! elf_add_dynamic_entry (info, DT_FINI, 0))
1371             return false;
1372         }
1373       strsize = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1374       if (! elf_add_dynamic_entry (info, DT_HASH, 0)
1375           || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
1376           || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
1377           || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
1378           || ! elf_add_dynamic_entry (info, DT_SYMENT,
1379                                       sizeof (Elf_External_Sym)))
1380         return false;
1381     }
1382
1383   /* The backend must work out the sizes of all the other dynamic
1384      sections.  */
1385   bed = get_elf_backend_data (output_bfd);
1386   if (! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
1387     return false;
1388
1389   if (elf_hash_table (info)->dynamic_sections_created)
1390     {
1391       size_t dynsymcount;
1392       asection *s;
1393       size_t i;
1394       size_t bucketcount = 0;
1395       Elf_Internal_Sym isym;
1396
1397       /* Set the size of the .dynsym and .hash sections.  We counted
1398          the number of dynamic symbols in elf_link_add_object_symbols.
1399          We will build the contents of .dynsym and .hash when we build
1400          the final symbol table, because until then we do not know the
1401          correct value to give the symbols.  We built the .dynstr
1402          section as we went along in elf_link_add_object_symbols.  */
1403       dynsymcount = elf_hash_table (info)->dynsymcount;
1404       s = bfd_get_section_by_name (dynobj, ".dynsym");
1405       BFD_ASSERT (s != NULL);
1406       s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
1407       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1408       if (s->contents == NULL && s->_raw_size != 0)
1409         {
1410           bfd_set_error (bfd_error_no_memory);
1411           return false;
1412         }
1413
1414       /* The first entry in .dynsym is a dummy symbol.  */
1415       isym.st_value = 0;
1416       isym.st_size = 0;
1417       isym.st_name = 0;
1418       isym.st_info = 0;
1419       isym.st_other = 0;
1420       isym.st_shndx = 0;
1421       elf_swap_symbol_out (output_bfd, &isym,
1422                            (PTR) (Elf_External_Sym *) s->contents);
1423
1424       for (i = 0; elf_buckets[i] != 0; i++)
1425         {
1426           bucketcount = elf_buckets[i];
1427           if (dynsymcount < elf_buckets[i + 1])
1428             break;
1429         }
1430
1431       s = bfd_get_section_by_name (dynobj, ".hash");
1432       BFD_ASSERT (s != NULL);
1433       s->_raw_size = (2 + bucketcount + dynsymcount) * (ARCH_SIZE / 8);
1434       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
1435       if (s->contents == NULL)
1436         {
1437           bfd_set_error (bfd_error_no_memory);
1438           return false;
1439         }
1440       memset (s->contents, 0, (size_t) s->_raw_size);
1441
1442       put_word (output_bfd, bucketcount, s->contents);
1443       put_word (output_bfd, dynsymcount, s->contents + (ARCH_SIZE / 8));
1444
1445       elf_hash_table (info)->bucketcount = bucketcount;
1446
1447       s = bfd_get_section_by_name (dynobj, ".dynstr");
1448       BFD_ASSERT (s != NULL);
1449       s->_raw_size = _bfd_stringtab_size (elf_hash_table (info)->dynstr);
1450
1451       if (! elf_add_dynamic_entry (info, DT_NULL, 0))
1452         return false;
1453     }
1454
1455   return true;
1456 }
1457
1458 /* This routine is used to export all defined symbols into the dynamic
1459    symbol table.  It is called via elf_link_hash_traverse.  */
1460
1461 static boolean
1462 elf_export_symbol (h, data)
1463      struct elf_link_hash_entry *h;
1464      PTR data;
1465 {
1466   struct elf_info_failed *eif = (struct elf_info_failed *) data;
1467
1468   if (h->dynindx == -1
1469       && (h->elf_link_hash_flags
1470           & (ELF_LINK_HASH_DEF_REGULAR | ELF_LINK_HASH_REF_REGULAR)) != 0)
1471     {
1472       if (! _bfd_elf_link_record_dynamic_symbol (eif->info, h))
1473         {
1474           eif->failed = true;
1475           return false;
1476         }
1477     }
1478
1479   return true;
1480 }
1481
1482 /* Make the backend pick a good value for a dynamic symbol.  This is
1483    called via elf_link_hash_traverse, and also calls itself
1484    recursively.  */
1485
1486 static boolean
1487 elf_adjust_dynamic_symbol (h, data)
1488      struct elf_link_hash_entry *h;
1489      PTR data;
1490 {
1491   struct elf_info_failed *eif = (struct elf_info_failed *) data;
1492   bfd *dynobj;
1493   struct elf_backend_data *bed;
1494
1495   /* If -Bsymbolic was used (which means to bind references to global
1496      symbols to the definition within the shared object), and this
1497      symbol was defined in a regular object, then it actually doesn't
1498      need a PLT entry.  */
1499   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1500       && eif->info->shared
1501       && eif->info->symbolic
1502       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1503     h->elf_link_hash_flags &=~ ELF_LINK_HASH_NEEDS_PLT;
1504
1505   /* If this symbol does not require a PLT entry, and it is not
1506      defined by a dynamic object, or is not referenced by a regular
1507      object, ignore it.  We do have to handle a weak defined symbol,
1508      even if no regular object refers to it, if we decided to add it
1509      to the dynamic symbol table.  FIXME: Do we normally need to worry
1510      about symbols which are defined by one dynamic object and
1511      referenced by another one?  */
1512   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0
1513       && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1514           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1515           || ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
1516               && (h->weakdef == NULL || h->weakdef->dynindx == -1))))
1517     return true;
1518
1519   /* If we've already adjusted this symbol, don't do it again.  This
1520      can happen via a recursive call.  */
1521   if ((h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
1522     return true;
1523
1524   /* Don't look at this symbol again.  Note that we must set this
1525      after checking the above conditions, because we may look at a
1526      symbol once, decide not to do anything, and then get called
1527      recursively later after REF_REGULAR is set below.  */
1528   h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
1529
1530   /* If this is a weak definition, and we know a real definition, and
1531      the real symbol is not itself defined by a regular object file,
1532      then get a good value for the real definition.  We handle the
1533      real symbol first, for the convenience of the backend routine.
1534
1535      Note that there is a confusing case here.  If the real definition
1536      is defined by a regular object file, we don't get the real symbol
1537      from the dynamic object, but we do get the weak symbol.  If the
1538      processor backend uses a COPY reloc, then if some routine in the
1539      dynamic object changes the real symbol, we will not see that
1540      change in the corresponding weak symbol.  This is the way other
1541      ELF linkers work as well, and seems to be a result of the shared
1542      library model.
1543
1544      I will clarify this issue.  Most SVR4 shared libraries define the
1545      variable _timezone and define timezone as a weak synonym.  The
1546      tzset call changes _timezone.  If you write
1547        extern int timezone;
1548        int _timezone = 5;
1549        int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
1550      you might expect that, since timezone is a synonym for _timezone,
1551      the same number will print both times.  However, if the processor
1552      backend uses a COPY reloc, then actually timezone will be copied
1553      into your process image, and, since you define _timezone
1554      yourself, _timezone will not.  Thus timezone and _timezone will
1555      wind up at different memory locations.  The tzset call will set
1556      _timezone, leaving timezone unchanged.  */
1557
1558   if (h->weakdef != NULL)
1559     {
1560       struct elf_link_hash_entry *weakdef;
1561
1562       BFD_ASSERT (h->root.type == bfd_link_hash_defined
1563                   || h->root.type == bfd_link_hash_defweak);
1564       weakdef = h->weakdef;
1565       BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
1566                   || weakdef->root.type == bfd_link_hash_defweak);
1567       BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
1568       if ((weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
1569         {
1570           /* This symbol is defined by a regular object file, so we
1571              will not do anything special.  Clear weakdef for the
1572              convenience of the processor backend.  */
1573           h->weakdef = NULL;
1574         }
1575       else
1576         {
1577           /* There is an implicit reference by a regular object file
1578              via the weak symbol.  */
1579           weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
1580           if (! elf_adjust_dynamic_symbol (weakdef, (PTR) eif))
1581             return false;
1582         }
1583     }
1584
1585   dynobj = elf_hash_table (eif->info)->dynobj;
1586   bed = get_elf_backend_data (dynobj);
1587   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
1588     {
1589       eif->failed = true;
1590       return false;
1591     }
1592
1593   return true;
1594 }
1595 \f
1596 /* Final phase of ELF linker.  */
1597
1598 /* A structure we use to avoid passing large numbers of arguments.  */
1599
1600 struct elf_final_link_info
1601 {
1602   /* General link information.  */
1603   struct bfd_link_info *info;
1604   /* Output BFD.  */
1605   bfd *output_bfd;
1606   /* Symbol string table.  */
1607   struct bfd_strtab_hash *symstrtab;
1608   /* .dynsym section.  */
1609   asection *dynsym_sec;
1610   /* .hash section.  */
1611   asection *hash_sec;
1612   /* Buffer large enough to hold contents of any section.  */
1613   bfd_byte *contents;
1614   /* Buffer large enough to hold external relocs of any section.  */
1615   PTR external_relocs;
1616   /* Buffer large enough to hold internal relocs of any section.  */
1617   Elf_Internal_Rela *internal_relocs;
1618   /* Buffer large enough to hold external local symbols of any input
1619      BFD.  */
1620   Elf_External_Sym *external_syms;
1621   /* Buffer large enough to hold internal local symbols of any input
1622      BFD.  */
1623   Elf_Internal_Sym *internal_syms;
1624   /* Array large enough to hold a symbol index for each local symbol
1625      of any input BFD.  */
1626   long *indices;
1627   /* Array large enough to hold a section pointer for each local
1628      symbol of any input BFD.  */
1629   asection **sections;
1630   /* Buffer to hold swapped out symbols.  */
1631   Elf_External_Sym *symbuf;
1632   /* Number of swapped out symbols in buffer.  */
1633   size_t symbuf_count;
1634   /* Number of symbols which fit in symbuf.  */
1635   size_t symbuf_size;
1636 };
1637
1638 static boolean elf_link_output_sym
1639   PARAMS ((struct elf_final_link_info *, const char *,
1640            Elf_Internal_Sym *, asection *));
1641 static boolean elf_link_flush_output_syms
1642   PARAMS ((struct elf_final_link_info *));
1643 static boolean elf_link_output_extsym
1644   PARAMS ((struct elf_link_hash_entry *, PTR));
1645 static boolean elf_link_input_bfd
1646   PARAMS ((struct elf_final_link_info *, bfd *));
1647 static boolean elf_reloc_link_order
1648   PARAMS ((bfd *, struct bfd_link_info *, asection *,
1649            struct bfd_link_order *));
1650
1651 /* This struct is used to pass information to routines called via
1652    elf_link_hash_traverse which must return failure.  */
1653
1654 struct elf_finfo_failed
1655 {
1656   boolean failed;
1657   struct elf_final_link_info *finfo;
1658 };
1659
1660 /* Do the final step of an ELF link.  */
1661
1662 boolean
1663 elf_bfd_final_link (abfd, info)
1664      bfd *abfd;
1665      struct bfd_link_info *info;
1666 {
1667   boolean dynamic;
1668   bfd *dynobj;
1669   struct elf_final_link_info finfo;
1670   register asection *o;
1671   register struct bfd_link_order *p;
1672   register bfd *sub;
1673   size_t max_contents_size;
1674   size_t max_external_reloc_size;
1675   size_t max_internal_reloc_count;
1676   size_t max_sym_count;
1677   file_ptr off;
1678   Elf_Internal_Sym elfsym;
1679   unsigned int i;
1680   Elf_Internal_Shdr *symtab_hdr;
1681   Elf_Internal_Shdr *symstrtab_hdr;
1682   struct elf_backend_data *bed = get_elf_backend_data (abfd);
1683   struct elf_finfo_failed eif;
1684
1685   if (info->shared)
1686     abfd->flags |= DYNAMIC;
1687
1688   dynamic = elf_hash_table (info)->dynamic_sections_created;
1689   dynobj = elf_hash_table (info)->dynobj;
1690
1691   finfo.info = info;
1692   finfo.output_bfd = abfd;
1693   finfo.symstrtab = elf_stringtab_init ();
1694   if (finfo.symstrtab == NULL)
1695     return false;
1696   if (! dynamic)
1697     {
1698       finfo.dynsym_sec = NULL;
1699       finfo.hash_sec = NULL;
1700     }
1701   else
1702     {
1703       finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
1704       finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
1705       BFD_ASSERT (finfo.dynsym_sec != NULL && finfo.hash_sec != NULL);
1706     }
1707   finfo.contents = NULL;
1708   finfo.external_relocs = NULL;
1709   finfo.internal_relocs = NULL;
1710   finfo.external_syms = NULL;
1711   finfo.internal_syms = NULL;
1712   finfo.indices = NULL;
1713   finfo.sections = NULL;
1714   finfo.symbuf = NULL;
1715   finfo.symbuf_count = 0;
1716
1717   /* Count up the number of relocations we will output for each output
1718      section, so that we know the sizes of the reloc sections.  We
1719      also figure out some maximum sizes.  */
1720   max_contents_size = 0;
1721   max_external_reloc_size = 0;
1722   max_internal_reloc_count = 0;
1723   max_sym_count = 0;
1724   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
1725     {
1726       o->reloc_count = 0;
1727
1728       for (p = o->link_order_head; p != NULL; p = p->next)
1729         {
1730           if (p->type == bfd_section_reloc_link_order
1731               || p->type == bfd_symbol_reloc_link_order)
1732             ++o->reloc_count;
1733           else if (p->type == bfd_indirect_link_order)
1734             {
1735               asection *sec;
1736
1737               sec = p->u.indirect.section;
1738
1739               if (info->relocateable)
1740                 o->reloc_count += sec->reloc_count;
1741
1742               if (sec->_raw_size > max_contents_size)
1743                 max_contents_size = sec->_raw_size;
1744               if (sec->_cooked_size > max_contents_size)
1745                 max_contents_size = sec->_cooked_size;
1746
1747               /* We are interested in just local symbols, not all
1748                  symbols.  */
1749               if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour)
1750                 {
1751                   size_t sym_count;
1752
1753                   if (elf_bad_symtab (sec->owner))
1754                     sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
1755                                  / sizeof (Elf_External_Sym));
1756                   else
1757                     sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
1758
1759                   if (sym_count > max_sym_count)
1760                     max_sym_count = sym_count;
1761
1762                   if ((sec->flags & SEC_RELOC) != 0)
1763                     {
1764                       size_t ext_size;
1765
1766                       ext_size = elf_section_data (sec)->rel_hdr.sh_size;
1767                       if (ext_size > max_external_reloc_size)
1768                         max_external_reloc_size = ext_size;
1769                       if (sec->reloc_count > max_internal_reloc_count)
1770                         max_internal_reloc_count = sec->reloc_count;
1771                     }
1772                 }
1773             }
1774         }
1775
1776       if (o->reloc_count > 0)
1777         o->flags |= SEC_RELOC;
1778       else
1779         {
1780           /* Explicitly clear the SEC_RELOC flag.  The linker tends to
1781              set it (this is probably a bug) and if it is set
1782              assign_section_numbers will create a reloc section.  */
1783           o->flags &=~ SEC_RELOC;
1784         }
1785
1786       /* If the SEC_ALLOC flag is not set, force the section VMA to
1787          zero.  This is done in elf_fake_sections as well, but forcing
1788          the VMA to 0 here will ensure that relocs against these
1789          sections are handled correctly.  */
1790       if ((o->flags & SEC_ALLOC) == 0)
1791         o->vma = 0;
1792     }
1793
1794   /* Figure out the file positions for everything but the symbol table
1795      and the relocs.  We set symcount to force assign_section_numbers
1796      to create a symbol table.  */
1797   abfd->symcount = info->strip == strip_all ? 0 : 1;
1798   BFD_ASSERT (! abfd->output_has_begun);
1799   if (! _bfd_elf_compute_section_file_positions (abfd, info))
1800     goto error_return;
1801
1802   /* That created the reloc sections.  Set their sizes, and assign
1803      them file positions, and allocate some buffers.  */
1804   for (o = abfd->sections; o != NULL; o = o->next)
1805     {
1806       if ((o->flags & SEC_RELOC) != 0)
1807         {
1808           Elf_Internal_Shdr *rel_hdr;
1809           register struct elf_link_hash_entry **p, **pend;
1810
1811           rel_hdr = &elf_section_data (o)->rel_hdr;
1812
1813           rel_hdr->sh_size = rel_hdr->sh_entsize * o->reloc_count;
1814
1815           /* The contents field must last into write_object_contents,
1816              so we allocate it with bfd_alloc rather than malloc.  */
1817           rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
1818           if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
1819             {
1820               bfd_set_error (bfd_error_no_memory);
1821               goto error_return;
1822             }
1823
1824           p = ((struct elf_link_hash_entry **)
1825                malloc (o->reloc_count
1826                        * sizeof (struct elf_link_hash_entry *)));
1827           if (p == NULL && o->reloc_count != 0)
1828             {
1829               bfd_set_error (bfd_error_no_memory);
1830               goto error_return;
1831             }
1832           elf_section_data (o)->rel_hashes = p;
1833           pend = p + o->reloc_count;
1834           for (; p < pend; p++)
1835             *p = NULL;
1836
1837           /* Use the reloc_count field as an index when outputting the
1838              relocs.  */
1839           o->reloc_count = 0;
1840         }
1841     }
1842
1843   _bfd_elf_assign_file_positions_for_relocs (abfd);
1844
1845   /* We have now assigned file positions for all the sections except
1846      .symtab and .strtab.  We start the .symtab section at the current
1847      file position, and write directly to it.  We build the .strtab
1848      section in memory.  When we add .dynsym support, we will build
1849      that in memory as well (.dynsym is smaller than .symtab).  */
1850   abfd->symcount = 0;
1851   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1852   /* sh_name is set in prep_headers.  */
1853   symtab_hdr->sh_type = SHT_SYMTAB;
1854   symtab_hdr->sh_flags = 0;
1855   symtab_hdr->sh_addr = 0;
1856   symtab_hdr->sh_size = 0;
1857   symtab_hdr->sh_entsize = sizeof (Elf_External_Sym);
1858   /* sh_link is set in assign_section_numbers.  */
1859   /* sh_info is set below.  */
1860   /* sh_offset is set just below.  */
1861   symtab_hdr->sh_addralign = 4;  /* FIXME: system dependent?  */
1862
1863   off = elf_tdata (abfd)->next_file_pos;
1864   off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
1865
1866   /* Note that at this point elf_tdata (abfd)->next_file_pos is
1867      incorrect.  We do not yet know the size of the .symtab section.
1868      We correct next_file_pos below, after we do know the size.  */
1869
1870   /* Allocate a buffer to hold swapped out symbols.  This is to avoid
1871      continuously seeking to the right position in the file.  */
1872   if (! info->keep_memory || max_sym_count < 20)
1873     finfo.symbuf_size = 20;
1874   else
1875     finfo.symbuf_size = max_sym_count;
1876   finfo.symbuf = ((Elf_External_Sym *)
1877                   malloc (finfo.symbuf_size * sizeof (Elf_External_Sym)));
1878   if (finfo.symbuf == NULL)
1879     {
1880       bfd_set_error (bfd_error_no_memory);
1881       goto error_return;
1882     }
1883
1884   /* Start writing out the symbol table.  The first symbol is always a
1885      dummy symbol.  */
1886   elfsym.st_value = 0;
1887   elfsym.st_size = 0;
1888   elfsym.st_info = 0;
1889   elfsym.st_other = 0;
1890   elfsym.st_shndx = SHN_UNDEF;
1891   if (! elf_link_output_sym (&finfo, (const char *) NULL,
1892                              &elfsym, bfd_und_section_ptr))
1893     goto error_return;
1894
1895 #if 0
1896   /* Some standard ELF linkers do this, but we don't because it causes
1897      bootstrap comparison failures.  */
1898   /* Output a file symbol for the output file as the second symbol.
1899      We output this even if we are discarding local symbols, although
1900      I'm not sure if this is correct.  */
1901   elfsym.st_value = 0;
1902   elfsym.st_size = 0;
1903   elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
1904   elfsym.st_other = 0;
1905   elfsym.st_shndx = SHN_ABS;
1906   if (! elf_link_output_sym (&finfo, bfd_get_filename (abfd),
1907                              &elfsym, bfd_abs_section_ptr))
1908     goto error_return;
1909 #endif
1910
1911   /* Output a symbol for each section.  We output these even if we are
1912      discarding local symbols, since they are used for relocs.  These
1913      symbols have no names.  We store the index of each one in the
1914      index field of the section, so that we can find it again when
1915      outputting relocs.  */
1916   elfsym.st_value = 0;
1917   elfsym.st_size = 0;
1918   elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1919   elfsym.st_other = 0;
1920   for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
1921     {
1922       o = section_from_elf_index (abfd, i);
1923       if (o != NULL)
1924         o->target_index = abfd->symcount;
1925       elfsym.st_shndx = i;
1926       if (! elf_link_output_sym (&finfo, (const char *) NULL,
1927                                  &elfsym, o))
1928         goto error_return;
1929     }
1930
1931   /* Allocate some memory to hold information read in from the input
1932      files.  */
1933   finfo.contents = (bfd_byte *) malloc (max_contents_size);
1934   finfo.external_relocs = (PTR) malloc (max_external_reloc_size);
1935   finfo.internal_relocs = ((Elf_Internal_Rela *)
1936                            malloc (max_internal_reloc_count
1937                                    * sizeof (Elf_Internal_Rela)));
1938   finfo.external_syms = ((Elf_External_Sym *)
1939                          malloc (max_sym_count * sizeof (Elf_External_Sym)));
1940   finfo.internal_syms = ((Elf_Internal_Sym *)
1941                          malloc (max_sym_count * sizeof (Elf_Internal_Sym)));
1942   finfo.indices = (long *) malloc (max_sym_count * sizeof (long));
1943   finfo.sections = (asection **) malloc (max_sym_count * sizeof (asection *));
1944   if ((finfo.contents == NULL && max_contents_size != 0)
1945       || (finfo.external_relocs == NULL && max_external_reloc_size != 0)
1946       || (finfo.internal_relocs == NULL && max_internal_reloc_count != 0)
1947       || (finfo.external_syms == NULL && max_sym_count != 0)
1948       || (finfo.internal_syms == NULL && max_sym_count != 0)
1949       || (finfo.indices == NULL && max_sym_count != 0)
1950       || (finfo.sections == NULL && max_sym_count != 0))
1951     {
1952       bfd_set_error (bfd_error_no_memory);
1953       goto error_return;
1954     }
1955
1956   /* Since ELF permits relocations to be against local symbols, we
1957      must have the local symbols available when we do the relocations.
1958      Since we would rather only read the local symbols once, and we
1959      would rather not keep them in memory, we handle all the
1960      relocations for a single input file at the same time.
1961
1962      Unfortunately, there is no way to know the total number of local
1963      symbols until we have seen all of them, and the local symbol
1964      indices precede the global symbol indices.  This means that when
1965      we are generating relocateable output, and we see a reloc against
1966      a global symbol, we can not know the symbol index until we have
1967      finished examining all the local symbols to see which ones we are
1968      going to output.  To deal with this, we keep the relocations in
1969      memory, and don't output them until the end of the link.  This is
1970      an unfortunate waste of memory, but I don't see a good way around
1971      it.  Fortunately, it only happens when performing a relocateable
1972      link, which is not the common case.  FIXME: If keep_memory is set
1973      we could write the relocs out and then read them again; I don't
1974      know how bad the memory loss will be.  */
1975
1976   for (sub = info->input_bfds; sub != NULL; sub = sub->next)
1977     sub->output_has_begun = false;
1978   for (o = abfd->sections; o != NULL; o = o->next)
1979     {
1980       for (p = o->link_order_head; p != NULL; p = p->next)
1981         {
1982           if (p->type == bfd_indirect_link_order
1983               && (bfd_get_flavour (p->u.indirect.section->owner)
1984                   == bfd_target_elf_flavour))
1985             {
1986               sub = p->u.indirect.section->owner;
1987               if (! sub->output_has_begun)
1988                 {
1989                   if (! elf_link_input_bfd (&finfo, sub))
1990                     goto error_return;
1991                   sub->output_has_begun = true;
1992                 }
1993             }
1994           else if (p->type == bfd_section_reloc_link_order
1995                    || p->type == bfd_symbol_reloc_link_order)
1996             {
1997               if (! elf_reloc_link_order (abfd, info, o, p))
1998                 goto error_return;
1999             }
2000           else
2001             {
2002               if (! _bfd_default_link_order (abfd, info, o, p))
2003                 goto error_return;
2004             }
2005         }
2006     }
2007
2008   /* That wrote out all the local symbols.  Finish up the symbol table
2009      with the global symbols.  */
2010
2011   /* The sh_info field records the index of the first non local
2012      symbol.  */
2013   symtab_hdr->sh_info = abfd->symcount;
2014   if (dynamic)
2015     elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info = 1;
2016
2017   /* We get the global symbols from the hash table.  */
2018   eif.failed = false;
2019   eif.finfo = &finfo;
2020   elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
2021                           (PTR) &eif);
2022   if (eif.failed)
2023     return false;
2024
2025   /* Flush all symbols to the file.  */
2026   if (! elf_link_flush_output_syms (&finfo))
2027     return false;
2028
2029   /* Now we know the size of the symtab section.  */
2030   off += symtab_hdr->sh_size;
2031
2032   /* Finish up and write out the symbol string table (.strtab)
2033      section.  */
2034   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
2035   /* sh_name was set in prep_headers.  */
2036   symstrtab_hdr->sh_type = SHT_STRTAB;
2037   symstrtab_hdr->sh_flags = 0;
2038   symstrtab_hdr->sh_addr = 0;
2039   symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
2040   symstrtab_hdr->sh_entsize = 0;
2041   symstrtab_hdr->sh_link = 0;
2042   symstrtab_hdr->sh_info = 0;
2043   /* sh_offset is set just below.  */
2044   symstrtab_hdr->sh_addralign = 1;
2045
2046   off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, true);
2047   elf_tdata (abfd)->next_file_pos = off;
2048
2049   if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
2050       || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
2051     return false;
2052
2053   /* Adjust the relocs to have the correct symbol indices.  */
2054   for (o = abfd->sections; o != NULL; o = o->next)
2055     {
2056       struct elf_link_hash_entry **rel_hash;
2057       Elf_Internal_Shdr *rel_hdr;
2058
2059       if ((o->flags & SEC_RELOC) == 0)
2060         continue;
2061
2062       rel_hash = elf_section_data (o)->rel_hashes;
2063       rel_hdr = &elf_section_data (o)->rel_hdr;
2064       for (i = 0; i < o->reloc_count; i++, rel_hash++)
2065         {
2066           if (*rel_hash == NULL)
2067             continue;
2068
2069           BFD_ASSERT ((*rel_hash)->indx >= 0);
2070
2071           if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2072             {
2073               Elf_External_Rel *erel;
2074               Elf_Internal_Rel irel;
2075
2076               erel = (Elf_External_Rel *) rel_hdr->contents + i;
2077               elf_swap_reloc_in (abfd, erel, &irel);
2078               irel.r_info = ELF_R_INFO ((*rel_hash)->indx,
2079                                         ELF_R_TYPE (irel.r_info));
2080               elf_swap_reloc_out (abfd, &irel, erel);
2081             }
2082           else
2083             {
2084               Elf_External_Rela *erela;
2085               Elf_Internal_Rela irela;
2086
2087               BFD_ASSERT (rel_hdr->sh_entsize
2088                           == sizeof (Elf_External_Rela));
2089
2090               erela = (Elf_External_Rela *) rel_hdr->contents + i;
2091               elf_swap_reloca_in (abfd, erela, &irela);
2092               irela.r_info = ELF_R_INFO ((*rel_hash)->indx,
2093                                          ELF_R_TYPE (irela.r_info));
2094               elf_swap_reloca_out (abfd, &irela, erela);
2095             }
2096         }
2097
2098       /* Set the reloc_count field to 0 to prevent write_relocs from
2099          trying to swap the relocs out itself.  */
2100       o->reloc_count = 0;
2101     }
2102
2103   /* If we are linking against a dynamic object, or generating a
2104      shared library, finish up the dynamic linking information.  */
2105   if (dynamic)
2106     {
2107       Elf_External_Dyn *dyncon, *dynconend;
2108
2109       /* Fix up .dynamic entries.  */
2110       o = bfd_get_section_by_name (dynobj, ".dynamic");
2111       BFD_ASSERT (o != NULL);
2112
2113       dyncon = (Elf_External_Dyn *) o->contents;
2114       dynconend = (Elf_External_Dyn *) (o->contents + o->_raw_size);
2115       for (; dyncon < dynconend; dyncon++)
2116         {
2117           Elf_Internal_Dyn dyn;
2118           const char *name;
2119           unsigned int type;
2120
2121           elf_swap_dyn_in (dynobj, dyncon, &dyn);
2122
2123           switch (dyn.d_tag)
2124             {
2125             default:
2126               break;
2127
2128               /* SVR4 linkers seem to set DT_INIT and DT_FINI based on
2129                  magic _init and _fini symbols.  This is pretty ugly,
2130                  but we are compatible.  */
2131             case DT_INIT:
2132               name = "_init";
2133               goto get_sym;
2134             case DT_FINI:
2135               name = "_fini";
2136             get_sym:
2137               {
2138                 struct elf_link_hash_entry *h;
2139
2140                 h = elf_link_hash_lookup (elf_hash_table (info), name,
2141                                           false, false, true);
2142                 if (h != NULL
2143                     && (h->root.type == bfd_link_hash_defined
2144                         || h->root.type == bfd_link_hash_defweak))
2145                   {
2146                     dyn.d_un.d_val = h->root.u.def.value;
2147                     o = h->root.u.def.section;
2148                     if (o->output_section != NULL)
2149                       dyn.d_un.d_val += (o->output_section->vma
2150                                          + o->output_offset);
2151                     else
2152                       {
2153                         /* The symbol is imported from another shared
2154                            library and does not apply to this one.  */
2155                         dyn.d_un.d_val = 0;
2156                       }
2157
2158                     elf_swap_dyn_out (dynobj, &dyn, dyncon);
2159                   }
2160               }
2161               break;
2162
2163             case DT_HASH:
2164               name = ".hash";
2165               goto get_vma;
2166             case DT_STRTAB:
2167               name = ".dynstr";
2168               goto get_vma;
2169             case DT_SYMTAB:
2170               name = ".dynsym";
2171             get_vma:
2172               o = bfd_get_section_by_name (abfd, name);
2173               BFD_ASSERT (o != NULL);
2174               dyn.d_un.d_ptr = o->vma;
2175               elf_swap_dyn_out (dynobj, &dyn, dyncon);
2176               break;
2177
2178             case DT_REL:
2179             case DT_RELA:
2180             case DT_RELSZ:
2181             case DT_RELASZ:
2182               if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
2183                 type = SHT_REL;
2184               else
2185                 type = SHT_RELA;
2186               dyn.d_un.d_val = 0;
2187               for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
2188                 {
2189                   Elf_Internal_Shdr *hdr;
2190
2191                   hdr = elf_elfsections (abfd)[i];
2192                   if (hdr->sh_type == type
2193                       && (hdr->sh_flags & SHF_ALLOC) != 0)
2194                     {
2195                       if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
2196                         dyn.d_un.d_val += hdr->sh_size;
2197                       else
2198                         {
2199                           if (dyn.d_un.d_val == 0
2200                               || hdr->sh_addr < dyn.d_un.d_val)
2201                             dyn.d_un.d_val = hdr->sh_addr;
2202                         }
2203                     }
2204                 }
2205               elf_swap_dyn_out (dynobj, &dyn, dyncon);
2206               break;
2207             }
2208         }
2209     }
2210
2211   /* If we have created any dynamic sections, then output them.  */
2212   if (dynobj != NULL)
2213     {
2214       if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
2215         goto error_return;
2216
2217       for (o = dynobj->sections; o != NULL; o = o->next)
2218         {
2219           if ((o->flags & SEC_HAS_CONTENTS) == 0
2220               || o->_raw_size == 0)
2221             continue;
2222           if ((o->flags & SEC_IN_MEMORY) == 0)
2223             {
2224               /* At this point, we are only interested in sections
2225                  created by elf_link_create_dynamic_sections.  FIXME:
2226                  This test is fragile.  */
2227               continue;
2228             }
2229           if ((elf_section_data (o->output_section)->this_hdr.sh_type
2230                != SHT_STRTAB)
2231               || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0)
2232             {
2233               if (! bfd_set_section_contents (abfd, o->output_section,
2234                                               o->contents, o->output_offset,
2235                                               o->_raw_size))
2236                 goto error_return;
2237             }
2238           else
2239             {
2240               file_ptr off;
2241
2242               /* The contents of the .dynstr section are actually in a
2243                  stringtab.  */
2244               off = elf_section_data (o->output_section)->this_hdr.sh_offset;
2245               if (bfd_seek (abfd, off, SEEK_SET) != 0
2246                   || ! _bfd_stringtab_emit (abfd,
2247                                             elf_hash_table (info)->dynstr))
2248                 goto error_return;
2249             }
2250         }
2251     }
2252
2253   if (finfo.symstrtab != NULL)
2254     _bfd_stringtab_free (finfo.symstrtab);
2255   if (finfo.contents != NULL)
2256     free (finfo.contents);
2257   if (finfo.external_relocs != NULL)
2258     free (finfo.external_relocs);
2259   if (finfo.internal_relocs != NULL)
2260     free (finfo.internal_relocs);
2261   if (finfo.external_syms != NULL)
2262     free (finfo.external_syms);
2263   if (finfo.internal_syms != NULL)
2264     free (finfo.internal_syms);
2265   if (finfo.indices != NULL)
2266     free (finfo.indices);
2267   if (finfo.sections != NULL)
2268     free (finfo.sections);
2269   if (finfo.symbuf != NULL)
2270     free (finfo.symbuf);
2271   for (o = abfd->sections; o != NULL; o = o->next)
2272     {
2273       if ((o->flags & SEC_RELOC) != 0
2274           && elf_section_data (o)->rel_hashes != NULL)
2275         free (elf_section_data (o)->rel_hashes);
2276     }
2277
2278   elf_tdata (abfd)->linker = true;
2279
2280   return true;
2281
2282  error_return:
2283   if (finfo.symstrtab != NULL)
2284     _bfd_stringtab_free (finfo.symstrtab);
2285   if (finfo.contents != NULL)
2286     free (finfo.contents);
2287   if (finfo.external_relocs != NULL)
2288     free (finfo.external_relocs);
2289   if (finfo.internal_relocs != NULL)
2290     free (finfo.internal_relocs);
2291   if (finfo.external_syms != NULL)
2292     free (finfo.external_syms);
2293   if (finfo.internal_syms != NULL)
2294     free (finfo.internal_syms);
2295   if (finfo.indices != NULL)
2296     free (finfo.indices);
2297   if (finfo.sections != NULL)
2298     free (finfo.sections);
2299   if (finfo.symbuf != NULL)
2300     free (finfo.symbuf);
2301   for (o = abfd->sections; o != NULL; o = o->next)
2302     {
2303       if ((o->flags & SEC_RELOC) != 0
2304           && elf_section_data (o)->rel_hashes != NULL)
2305         free (elf_section_data (o)->rel_hashes);
2306     }
2307
2308   return false;
2309 }
2310
2311 /* Add a symbol to the output symbol table.  */
2312
2313 static boolean
2314 elf_link_output_sym (finfo, name, elfsym, input_sec)
2315      struct elf_final_link_info *finfo;
2316      const char *name;
2317      Elf_Internal_Sym *elfsym;
2318      asection *input_sec;
2319 {
2320   boolean (*output_symbol_hook) PARAMS ((bfd *,
2321                                          struct bfd_link_info *info,
2322                                          const char *,
2323                                          Elf_Internal_Sym *,
2324                                          asection *));
2325
2326   output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
2327     elf_backend_link_output_symbol_hook;
2328   if (output_symbol_hook != NULL)
2329     {
2330       if (! ((*output_symbol_hook)
2331              (finfo->output_bfd, finfo->info, name, elfsym, input_sec)))
2332         return false;
2333     }
2334
2335   if (name == (const char *) NULL || *name == '\0')
2336     elfsym->st_name = 0;
2337   else
2338     {
2339       elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
2340                                                             name, true,
2341                                                             false);
2342       if (elfsym->st_name == (unsigned long) -1)
2343         return false;
2344     }
2345
2346   if (finfo->symbuf_count >= finfo->symbuf_size)
2347     {
2348       if (! elf_link_flush_output_syms (finfo))
2349         return false;
2350     }
2351
2352   elf_swap_symbol_out (finfo->output_bfd, elfsym,
2353                        (PTR) (finfo->symbuf + finfo->symbuf_count));
2354   ++finfo->symbuf_count;
2355
2356   ++finfo->output_bfd->symcount;
2357
2358   return true;
2359 }
2360
2361 /* Flush the output symbols to the file.  */
2362
2363 static boolean
2364 elf_link_flush_output_syms (finfo)
2365      struct elf_final_link_info *finfo;
2366 {
2367   Elf_Internal_Shdr *symtab;
2368
2369   symtab = &elf_tdata (finfo->output_bfd)->symtab_hdr;
2370
2371   if (bfd_seek (finfo->output_bfd, symtab->sh_offset + symtab->sh_size,
2372                 SEEK_SET) != 0
2373       || (bfd_write ((PTR) finfo->symbuf, finfo->symbuf_count,
2374                      sizeof (Elf_External_Sym), finfo->output_bfd)
2375           != finfo->symbuf_count * sizeof (Elf_External_Sym)))
2376     return false;
2377
2378   symtab->sh_size += finfo->symbuf_count * sizeof (Elf_External_Sym);
2379
2380   finfo->symbuf_count = 0;
2381
2382   return true;
2383 }
2384
2385 /* Add an external symbol to the symbol table.  This is called from
2386    the hash table traversal routine.  */
2387
2388 static boolean
2389 elf_link_output_extsym (h, data)
2390      struct elf_link_hash_entry *h;
2391      PTR data;
2392 {
2393   struct elf_finfo_failed *eif = (struct elf_finfo_failed *) data;
2394   struct elf_final_link_info *finfo = eif->finfo;
2395   boolean strip;
2396   Elf_Internal_Sym sym;
2397   asection *input_sec;
2398
2399   /* If we are not creating a shared library, and this symbol is
2400      referenced by a shared library but is not defined anywhere, then
2401      warn that it is undefined.  If we do not do this, the runtime
2402      linker will complain that the symbol is undefined when the
2403      program is run.  We don't have to worry about symbols that are
2404      referenced by regular files, because we will already have issued
2405      warnings for them.  */
2406   if (! finfo->info->relocateable
2407       && ! finfo->info->shared
2408       && h->root.type == bfd_link_hash_undefined
2409       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
2410       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2411     {
2412       if (! ((*finfo->info->callbacks->undefined_symbol)
2413              (finfo->info, h->root.root.string, h->root.u.undef.abfd,
2414               (asection *) NULL, 0)))
2415         {
2416           eif->failed = true;
2417           return false;
2418         }
2419     }
2420
2421   /* We don't want to output symbols that have never been mentioned by
2422      a regular file, or that we have been told to strip.  However, if
2423      h->indx is set to -2, the symbol is used by a reloc and we must
2424      output it.  */
2425   if (h->indx == -2)
2426     strip = false;
2427   else if (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2428             || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2429            && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2430            && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2431     strip = true;
2432   else if (finfo->info->strip == strip_all
2433            || (finfo->info->strip == strip_some
2434                && bfd_hash_lookup (finfo->info->keep_hash,
2435                                    h->root.root.string,
2436                                    false, false) == NULL))
2437     strip = true;
2438   else
2439     strip = false;
2440
2441   /* If we're stripping it, and it's not a dynamic symbol, there's
2442      nothing else to do.  */
2443   if (strip && h->dynindx == -1)
2444     return true;
2445
2446   sym.st_value = 0;
2447   sym.st_size = h->size;
2448   sym.st_other = 0;
2449   if (h->root.type == bfd_link_hash_undefweak
2450       || h->root.type == bfd_link_hash_defweak)
2451     sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
2452   else
2453     sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
2454
2455   switch (h->root.type)
2456     {
2457     default:
2458     case bfd_link_hash_new:
2459       abort ();
2460       return false;
2461
2462     case bfd_link_hash_undefined:
2463       input_sec = bfd_und_section_ptr;
2464       sym.st_shndx = SHN_UNDEF;
2465       break;
2466
2467     case bfd_link_hash_undefweak:
2468       input_sec = bfd_und_section_ptr;
2469       sym.st_shndx = SHN_UNDEF;
2470       break;
2471
2472     case bfd_link_hash_defined:
2473     case bfd_link_hash_defweak:
2474       {
2475         input_sec = h->root.u.def.section;
2476         if (input_sec->output_section != NULL)
2477           {
2478             sym.st_shndx =
2479               _bfd_elf_section_from_bfd_section (finfo->output_bfd,
2480                                                  input_sec->output_section);
2481             if (sym.st_shndx == (unsigned short) -1)
2482               {
2483                 eif->failed = true;
2484                 return false;
2485               }
2486
2487             /* ELF symbols in relocateable files are section relative,
2488                but in nonrelocateable files they are virtual
2489                addresses.  */
2490             sym.st_value = h->root.u.def.value + input_sec->output_offset;
2491             if (! finfo->info->relocateable)
2492               sym.st_value += input_sec->output_section->vma;
2493           }
2494         else
2495           {
2496             BFD_ASSERT ((bfd_get_flavour (input_sec->owner)
2497                          == bfd_target_elf_flavour)
2498                         && elf_elfheader (input_sec->owner)->e_type == ET_DYN);
2499             sym.st_shndx = SHN_UNDEF;
2500             input_sec = bfd_und_section_ptr;
2501           }
2502       }
2503       break;
2504
2505     case bfd_link_hash_common:
2506       input_sec = bfd_com_section_ptr;
2507       sym.st_shndx = SHN_COMMON;
2508       sym.st_value = 1 << h->root.u.c.p->alignment_power;
2509       break;
2510
2511     case bfd_link_hash_indirect:
2512     case bfd_link_hash_warning:
2513       return (elf_link_output_extsym
2514               ((struct elf_link_hash_entry *) h->root.u.i.link, data));
2515     }
2516
2517   /* If this symbol should be put in the .dynsym section, then put it
2518      there now.  We have already know the symbol index.  We also fill
2519      in the entry in the .hash section.  */
2520   if (h->dynindx != -1
2521       && elf_hash_table (finfo->info)->dynamic_sections_created)
2522     {
2523       struct elf_backend_data *bed;
2524       size_t bucketcount;
2525       size_t bucket;
2526       bfd_byte *bucketpos;
2527       bfd_vma chain;
2528
2529       sym.st_name = h->dynstr_index;
2530
2531       /* Give the processor backend a chance to tweak the symbol
2532          value, and also to finish up anything that needs to be done
2533          for this symbol.  */
2534       bed = get_elf_backend_data (finfo->output_bfd);
2535       if (! ((*bed->elf_backend_finish_dynamic_symbol)
2536              (finfo->output_bfd, finfo->info, h, &sym)))
2537         {
2538           eif->failed = true;
2539           return false;
2540         }
2541
2542       elf_swap_symbol_out (finfo->output_bfd, &sym,
2543                            (PTR) (((Elf_External_Sym *)
2544                                    finfo->dynsym_sec->contents)
2545                                   + h->dynindx));
2546
2547       bucketcount = elf_hash_table (finfo->info)->bucketcount;
2548       bucket = (bfd_elf_hash ((const unsigned char *) h->root.root.string)
2549                 % bucketcount);
2550       bucketpos = ((bfd_byte *) finfo->hash_sec->contents
2551                    + (bucket + 2) * (ARCH_SIZE / 8));
2552       chain = get_word (finfo->output_bfd, bucketpos);
2553       put_word (finfo->output_bfd, h->dynindx, bucketpos);
2554       put_word (finfo->output_bfd, chain,
2555                 ((bfd_byte *) finfo->hash_sec->contents
2556                  + (bucketcount + 2 + h->dynindx) * (ARCH_SIZE / 8)));
2557     }
2558
2559   /* If we're stripping it, then it was just a dynamic symbol, and
2560      there's nothing else to do.  */
2561   if (strip)
2562     return true;
2563
2564   h->indx = finfo->output_bfd->symcount;
2565
2566   if (! elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec))
2567     {
2568       eif->failed = true;
2569       return false;
2570     }
2571
2572   return true;
2573 }
2574
2575 /* Link an input file into the linker output file.  This function
2576    handles all the sections and relocations of the input file at once.
2577    This is so that we only have to read the local symbols once, and
2578    don't have to keep them in memory.  */
2579
2580 static boolean
2581 elf_link_input_bfd (finfo, input_bfd)
2582      struct elf_final_link_info *finfo;
2583      bfd *input_bfd;
2584 {
2585   boolean (*relocate_section) PARAMS ((bfd *, struct bfd_link_info *,
2586                                        bfd *, asection *, bfd_byte *,
2587                                        Elf_Internal_Rela *,
2588                                        Elf_Internal_Sym *, asection **));
2589   bfd *output_bfd;
2590   Elf_Internal_Shdr *symtab_hdr;
2591   size_t locsymcount;
2592   size_t extsymoff;
2593   Elf_External_Sym *esym;
2594   Elf_External_Sym *esymend;
2595   Elf_Internal_Sym *isym;
2596   long *pindex;
2597   asection **ppsection;
2598   asection *o;
2599
2600   output_bfd = finfo->output_bfd;
2601   relocate_section =
2602     get_elf_backend_data (output_bfd)->elf_backend_relocate_section;
2603
2604   /* If this is a dynamic object, we don't want to do anything here:
2605      we don't want the local symbols, and we don't want the section
2606      contents.  */
2607   if (elf_elfheader (input_bfd)->e_type == ET_DYN)
2608     return true;
2609
2610   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2611   if (elf_bad_symtab (input_bfd))
2612     {
2613       locsymcount = symtab_hdr->sh_size / sizeof (Elf_External_Sym);
2614       extsymoff = 0;
2615     }
2616   else
2617     {
2618       locsymcount = symtab_hdr->sh_info;
2619       extsymoff = symtab_hdr->sh_info;
2620     }
2621
2622   /* Read the local symbols.  */
2623   if (locsymcount > 0
2624       && (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2625           || (bfd_read (finfo->external_syms, sizeof (Elf_External_Sym),
2626                         locsymcount, input_bfd)
2627               != locsymcount * sizeof (Elf_External_Sym))))
2628     return false;
2629
2630   /* Swap in the local symbols and write out the ones which we know
2631      are going into the output file.  */
2632   esym = finfo->external_syms;
2633   esymend = esym + locsymcount;
2634   isym = finfo->internal_syms;
2635   pindex = finfo->indices;
2636   ppsection = finfo->sections;
2637   for (; esym < esymend; esym++, isym++, pindex++, ppsection++)
2638     {
2639       asection *isec;
2640       const char *name;
2641       Elf_Internal_Sym osym;
2642
2643       elf_swap_symbol_in (input_bfd, esym, isym);
2644       *pindex = -1;
2645
2646       if (elf_bad_symtab (input_bfd))
2647         {
2648           if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
2649             {
2650               *ppsection = NULL;
2651               continue;
2652             }
2653         }
2654
2655       if (isym->st_shndx == SHN_UNDEF)
2656         isec = bfd_und_section_ptr;
2657       else if (isym->st_shndx > 0 && isym->st_shndx < SHN_LORESERVE)
2658         isec = section_from_elf_index (input_bfd, isym->st_shndx);
2659       else if (isym->st_shndx == SHN_ABS)
2660         isec = bfd_abs_section_ptr;
2661       else if (isym->st_shndx == SHN_COMMON)
2662         isec = bfd_com_section_ptr;
2663       else
2664         {
2665           /* Who knows?  */
2666           isec = NULL;
2667         }
2668
2669       *ppsection = isec;
2670
2671       /* Don't output the first, undefined, symbol.  */
2672       if (esym == finfo->external_syms)
2673         continue;
2674
2675       /* If we are stripping all symbols, we don't want to output this
2676          one.  */
2677       if (finfo->info->strip == strip_all)
2678         continue;
2679
2680       /* We never output section symbols.  Instead, we use the section
2681          symbol of the corresponding section in the output file.  */
2682       if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2683         continue;
2684
2685       /* If we are discarding all local symbols, we don't want to
2686          output this one.  If we are generating a relocateable output
2687          file, then some of the local symbols may be required by
2688          relocs; we output them below as we discover that they are
2689          needed.  */
2690       if (finfo->info->discard == discard_all)
2691         continue;
2692
2693       /* Get the name of the symbol.  */
2694       name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
2695                                           isym->st_name);
2696       if (name == NULL)
2697         return false;
2698
2699       /* See if we are discarding symbols with this name.  */
2700       if ((finfo->info->strip == strip_some
2701            && (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
2702                == NULL))
2703           || (finfo->info->discard == discard_l
2704               && strncmp (name, finfo->info->lprefix,
2705                           finfo->info->lprefix_len) == 0))
2706         continue;
2707
2708       /* If we get here, we are going to output this symbol.  */
2709
2710       osym = *isym;
2711
2712       /* Adjust the section index for the output file.  */
2713       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
2714                                                          isec->output_section);
2715       if (osym.st_shndx == (unsigned short) -1)
2716         return false;
2717
2718       *pindex = output_bfd->symcount;
2719
2720       /* ELF symbols in relocateable files are section relative, but
2721          in executable files they are virtual addresses.  Note that
2722          this code assumes that all ELF sections have an associated
2723          BFD section with a reasonable value for output_offset; below
2724          we assume that they also have a reasonable value for
2725          output_section.  Any special sections must be set up to meet
2726          these requirements.  */
2727       osym.st_value += isec->output_offset;
2728       if (! finfo->info->relocateable)
2729         osym.st_value += isec->output_section->vma;
2730
2731       if (! elf_link_output_sym (finfo, name, &osym, isec))
2732         return false;
2733     }
2734
2735   /* Relocate the contents of each section.  */
2736   for (o = input_bfd->sections; o != NULL; o = o->next)
2737     {
2738       if ((o->flags & SEC_HAS_CONTENTS) == 0)
2739         continue;
2740
2741       if ((o->flags & SEC_IN_MEMORY) != 0
2742           && input_bfd == elf_hash_table (finfo->info)->dynobj)
2743         {
2744           /* Section was created by elf_link_create_dynamic_sections.
2745              FIXME: This test is fragile.  */
2746           continue;
2747         }
2748
2749       /* Read the contents of the section.  */
2750       if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2751                                       (file_ptr) 0, o->_raw_size))
2752         return false;
2753
2754       if ((o->flags & SEC_RELOC) != 0)
2755         {
2756           Elf_Internal_Rela *internal_relocs;
2757
2758           /* Get the swapped relocs.  */
2759           internal_relocs = elf_link_read_relocs (input_bfd, o,
2760                                                   finfo->external_relocs,
2761                                                   finfo->internal_relocs,
2762                                                   false);
2763           if (internal_relocs == NULL
2764               && o->reloc_count > 0)
2765             return false;
2766
2767           /* Relocate the section by invoking a back end routine.
2768
2769              The back end routine is responsible for adjusting the
2770              section contents as necessary, and (if using Rela relocs
2771              and generating a relocateable output file) adjusting the
2772              reloc addend as necessary.
2773
2774              The back end routine does not have to worry about setting
2775              the reloc address or the reloc symbol index.
2776
2777              The back end routine is given a pointer to the swapped in
2778              internal symbols, and can access the hash table entries
2779              for the external symbols via elf_sym_hashes (input_bfd).
2780
2781              When generating relocateable output, the back end routine
2782              must handle STB_LOCAL/STT_SECTION symbols specially.  The
2783              output symbol is going to be a section symbol
2784              corresponding to the output section, which will require
2785              the addend to be adjusted.  */
2786
2787           if (! (*relocate_section) (output_bfd, finfo->info,
2788                                      input_bfd, o,
2789                                      finfo->contents,
2790                                      internal_relocs,
2791                                      finfo->internal_syms,
2792                                      finfo->sections))
2793             return false;
2794
2795           if (finfo->info->relocateable)
2796             {
2797               Elf_Internal_Rela *irela;
2798               Elf_Internal_Rela *irelaend;
2799               struct elf_link_hash_entry **rel_hash;
2800               Elf_Internal_Shdr *input_rel_hdr;
2801               Elf_Internal_Shdr *output_rel_hdr;
2802
2803               /* Adjust the reloc addresses and symbol indices.  */
2804
2805               irela = internal_relocs;
2806               irelaend = irela + o->reloc_count;
2807               rel_hash = (elf_section_data (o->output_section)->rel_hashes
2808                           + o->output_section->reloc_count);
2809               for (; irela < irelaend; irela++, rel_hash++)
2810                 {
2811                   long r_symndx;
2812                   Elf_Internal_Sym *isym;
2813                   asection *sec;
2814
2815                   irela->r_offset += o->output_offset;
2816
2817                   r_symndx = ELF_R_SYM (irela->r_info);
2818
2819                   if (r_symndx == 0)
2820                     continue;
2821
2822                   if (r_symndx >= locsymcount
2823                       || (elf_bad_symtab (input_bfd)
2824                           && finfo->sections[r_symndx] == NULL))
2825                     {
2826                       long indx;
2827
2828                       /* This is a reloc against a global symbol.  We
2829                          have not yet output all the local symbols, so
2830                          we do not know the symbol index of any global
2831                          symbol.  We set the rel_hash entry for this
2832                          reloc to point to the global hash table entry
2833                          for this symbol.  The symbol index is then
2834                          set at the end of elf_bfd_final_link.  */
2835                       indx = r_symndx - extsymoff;
2836                       *rel_hash = elf_sym_hashes (input_bfd)[indx];
2837
2838                       /* Setting the index to -2 tells
2839                          elf_link_output_extsym that this symbol is
2840                          used by a reloc.  */
2841                       BFD_ASSERT ((*rel_hash)->indx < 0);
2842                       (*rel_hash)->indx = -2;
2843
2844                       continue;
2845                     }
2846
2847                   /* This is a reloc against a local symbol. */
2848
2849                   *rel_hash = NULL;
2850                   isym = finfo->internal_syms + r_symndx;
2851                   sec = finfo->sections[r_symndx];
2852                   if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2853                     {
2854                       /* I suppose the backend ought to fill in the
2855                          section of any STT_SECTION symbol against a
2856                          processor specific section.  */
2857                       if (sec != NULL && bfd_is_abs_section (sec))
2858                         r_symndx = 0;
2859                       else if (sec == NULL || sec->owner == NULL)
2860                         {
2861                           bfd_set_error (bfd_error_bad_value);
2862                           return false;
2863                         }
2864                       else
2865                         {
2866                           r_symndx = sec->output_section->target_index;
2867                           BFD_ASSERT (r_symndx != 0);
2868                         }
2869                     }
2870                   else
2871                     {
2872                       if (finfo->indices[r_symndx] == -1)
2873                         {
2874                           unsigned long link;
2875                           const char *name;
2876                           asection *osec;
2877
2878                           if (finfo->info->strip == strip_all)
2879                             {
2880                               /* You can't do ld -r -s.  */
2881                               bfd_set_error (bfd_error_invalid_operation);
2882                               return false;
2883                             }
2884
2885                           /* This symbol was skipped earlier, but
2886                              since it is needed by a reloc, we
2887                              must output it now.  */
2888                           link = symtab_hdr->sh_link;
2889                           name = bfd_elf_string_from_elf_section (input_bfd,
2890                                                                   link,
2891                                                                   isym->st_name);
2892                           if (name == NULL)
2893                             return false;
2894
2895                           osec = sec->output_section;
2896                           isym->st_shndx =
2897                             _bfd_elf_section_from_bfd_section (output_bfd,
2898                                                                osec);
2899                           if (isym->st_shndx == (unsigned short) -1)
2900                             return false;
2901
2902                           isym->st_value += sec->output_offset;
2903                           if (! finfo->info->relocateable)
2904                             isym->st_value += osec->vma;
2905
2906                           finfo->indices[r_symndx] = output_bfd->symcount;
2907
2908                           if (! elf_link_output_sym (finfo, name, isym, sec))
2909                             return false;
2910                         }
2911
2912                       r_symndx = finfo->indices[r_symndx];
2913                     }
2914
2915                   irela->r_info = ELF_R_INFO (r_symndx,
2916                                               ELF_R_TYPE (irela->r_info));
2917                 }
2918
2919               /* Swap out the relocs.  */
2920               input_rel_hdr = &elf_section_data (o)->rel_hdr;
2921               output_rel_hdr = &elf_section_data (o->output_section)->rel_hdr;
2922               BFD_ASSERT (output_rel_hdr->sh_entsize
2923                           == input_rel_hdr->sh_entsize);
2924               irela = internal_relocs;
2925               irelaend = irela + o->reloc_count;
2926               if (input_rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
2927                 {
2928                   Elf_External_Rel *erel;
2929
2930                   erel = ((Elf_External_Rel *) output_rel_hdr->contents
2931                           + o->output_section->reloc_count);
2932                   for (; irela < irelaend; irela++, erel++)
2933                     {
2934                       Elf_Internal_Rel irel;
2935
2936                       irel.r_offset = irela->r_offset;
2937                       irel.r_info = irela->r_info;
2938                       BFD_ASSERT (irela->r_addend == 0);
2939                       elf_swap_reloc_out (output_bfd, &irel, erel);
2940                     }
2941                 }
2942               else
2943                 {
2944                   Elf_External_Rela *erela;
2945
2946                   BFD_ASSERT (input_rel_hdr->sh_entsize
2947                               == sizeof (Elf_External_Rela));
2948                   erela = ((Elf_External_Rela *) output_rel_hdr->contents
2949                            + o->output_section->reloc_count);
2950                   for (; irela < irelaend; irela++, erela++)
2951                     elf_swap_reloca_out (output_bfd, irela, erela);
2952                 }
2953
2954               o->output_section->reloc_count += o->reloc_count;
2955             }
2956         }
2957
2958       /* Write out the modified section contents.  */
2959       if (! bfd_set_section_contents (output_bfd, o->output_section,
2960                                       finfo->contents, o->output_offset,
2961                                       (o->_cooked_size != 0
2962                                        ? o->_cooked_size
2963                                        : o->_raw_size)))
2964         return false;
2965     }
2966
2967   return true;
2968 }
2969
2970 /* Generate a reloc when linking an ELF file.  This is a reloc
2971    requested by the linker, and does come from any input file.  This
2972    is used to build constructor and destructor tables when linking
2973    with -Ur.  */
2974
2975 static boolean
2976 elf_reloc_link_order (output_bfd, info, output_section, link_order)
2977      bfd *output_bfd;
2978      struct bfd_link_info *info;
2979      asection *output_section;
2980      struct bfd_link_order *link_order;
2981 {
2982   reloc_howto_type *howto;
2983   long indx;
2984   bfd_vma offset;
2985   struct elf_link_hash_entry **rel_hash_ptr;
2986   Elf_Internal_Shdr *rel_hdr;
2987
2988   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2989   if (howto == NULL)
2990     {
2991       bfd_set_error (bfd_error_bad_value);
2992       return false;
2993     }
2994
2995   /* If this is an inplace reloc, we must write the addend into the
2996      object file.  */
2997   if (howto->partial_inplace
2998       && link_order->u.reloc.p->addend != 0)
2999     {
3000       bfd_size_type size;
3001       bfd_reloc_status_type rstat;
3002       bfd_byte *buf;
3003       boolean ok;
3004
3005       size = bfd_get_reloc_size (howto);
3006       buf = (bfd_byte *) bfd_zmalloc (size);
3007       if (buf == (bfd_byte *) NULL)
3008         {
3009           bfd_set_error (bfd_error_no_memory);
3010           return false;
3011         }
3012       rstat = _bfd_relocate_contents (howto, output_bfd,
3013                                       link_order->u.reloc.p->addend, buf);
3014       switch (rstat)
3015         {
3016         case bfd_reloc_ok:
3017           break;
3018         default:
3019         case bfd_reloc_outofrange:
3020           abort ();
3021         case bfd_reloc_overflow:
3022           if (! ((*info->callbacks->reloc_overflow)
3023                  (info,
3024                   (link_order->type == bfd_section_reloc_link_order
3025                    ? bfd_section_name (output_bfd,
3026                                        link_order->u.reloc.p->u.section)
3027                    : link_order->u.reloc.p->u.name),
3028                   howto->name, link_order->u.reloc.p->addend,
3029                   (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
3030             {
3031               free (buf);
3032               return false;
3033             }
3034           break;
3035         }
3036       ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
3037                                      (file_ptr) link_order->offset, size);
3038       free (buf);
3039       if (! ok)
3040         return false;
3041     }
3042
3043   /* Figure out the symbol index.  */
3044   rel_hash_ptr = (elf_section_data (output_section)->rel_hashes
3045                   + output_section->reloc_count);
3046   if (link_order->type == bfd_section_reloc_link_order)
3047     {
3048       indx = link_order->u.reloc.p->u.section->target_index;
3049       BFD_ASSERT (indx != 0);
3050       *rel_hash_ptr = NULL;
3051     }
3052   else
3053     {
3054       struct elf_link_hash_entry *h;
3055
3056       h = elf_link_hash_lookup (elf_hash_table (info),
3057                                 link_order->u.reloc.p->u.name,
3058                                 false, false, true);
3059       if (h != NULL)
3060         {
3061           /* Setting the index to -2 tells elf_link_output_extsym that
3062              this symbol is used by a reloc.  */
3063           h->indx = -2;
3064           *rel_hash_ptr = h;
3065           indx = 0;
3066         }
3067       else
3068         {
3069           if (! ((*info->callbacks->unattached_reloc)
3070                  (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
3071                   (asection *) NULL, (bfd_vma) 0)))
3072             return false;
3073           indx = 0;
3074         }
3075     }
3076
3077   /* The address of a reloc is relative to the section in a
3078      relocateable file, and is a virtual address in an executable
3079      file.  */
3080   offset = link_order->offset;
3081   if (! info->relocateable)
3082     offset += output_section->vma;
3083
3084   rel_hdr = &elf_section_data (output_section)->rel_hdr;
3085
3086   if (rel_hdr->sh_type == SHT_REL)
3087     {
3088       Elf_Internal_Rel irel;
3089       Elf_External_Rel *erel;
3090
3091       irel.r_offset = offset;
3092       irel.r_info = ELF_R_INFO (indx, howto->type);
3093       erel = ((Elf_External_Rel *) rel_hdr->contents
3094               + output_section->reloc_count);
3095       elf_swap_reloc_out (output_bfd, &irel, erel);
3096     }
3097   else
3098     {
3099       Elf_Internal_Rela irela;
3100       Elf_External_Rela *erela;
3101
3102       irela.r_offset = offset;
3103       irela.r_info = ELF_R_INFO (indx, howto->type);
3104       irela.r_addend = link_order->u.reloc.p->addend;
3105       erela = ((Elf_External_Rela *) rel_hdr->contents
3106                + output_section->reloc_count);
3107       elf_swap_reloca_out (output_bfd, &irela, erela);
3108     }
3109
3110   ++output_section->reloc_count;
3111
3112   return true;
3113 }
3114