bfd/elf.c

   1 /* ELF executable support for BFD.
   2
   3    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   4    2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 /*
  23 SECTION
  24         ELF backends
  25
  26         BFD support for ELF formats is being worked on.
  27         Currently, the best supported back ends are for sparc and i386
  28         (running svr4 or Solaris 2).
  29
  30         Documentation of the internals of the support code still needs
  31         to be written.  The code is changing quickly enough that we
  32         haven't bothered yet.  */
  33
  34 /* For sparc64-cross-sparc32.  */
  35 #define _SYSCALL32
  36 #include "bfd.h"
  37 #include "sysdep.h"
  38 #include "bfdlink.h"
  39 #include "libbfd.h"
  40 #define ARCH_SIZE 0
  41 #include "elf-bfd.h"
  42 #include "libiberty.h"
  43
  44 static int elf_sort_sections (const void *, const void *);
  45 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
  46 static bfd_boolean prep_headers (bfd *);
  47 static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
  48 static bfd_boolean elfcore_read_notes (bfd *, file_ptr, bfd_size_type) ;
  49
  50 /* Swap version information in and out.  The version information is
  51    currently size independent.  If that ever changes, this code will
  52    need to move into elfcode.h.  */
  53
  54 /* Swap in a Verdef structure.  */
  55
  56 void
  57 _bfd_elf_swap_verdef_in (bfd *abfd,
  58                          const Elf_External_Verdef *src,
  59                          Elf_Internal_Verdef *dst)
  60 {
  61   dst->vd_version = H_GET_16 (abfd, src->vd_version);
  62   dst->vd_flags   = H_GET_16 (abfd, src->vd_flags);
  63   dst->vd_ndx     = H_GET_16 (abfd, src->vd_ndx);
  64   dst->vd_cnt     = H_GET_16 (abfd, src->vd_cnt);
  65   dst->vd_hash    = H_GET_32 (abfd, src->vd_hash);
  66   dst->vd_aux     = H_GET_32 (abfd, src->vd_aux);
  67   dst->vd_next    = H_GET_32 (abfd, src->vd_next);
  68 }
  69
  70 /* Swap out a Verdef structure.  */
  71
  72 void
  73 _bfd_elf_swap_verdef_out (bfd *abfd,
  74                           const Elf_Internal_Verdef *src,
  75                           Elf_External_Verdef *dst)
  76 {
  77   H_PUT_16 (abfd, src->vd_version, dst->vd_version);
  78   H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
  79   H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
  80   H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
  81   H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
  82   H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
  83   H_PUT_32 (abfd, src->vd_next, dst->vd_next);
  84 }
  85
  86 /* Swap in a Verdaux structure.  */
  87
  88 void
  89 _bfd_elf_swap_verdaux_in (bfd *abfd,
  90                           const Elf_External_Verdaux *src,
  91                           Elf_Internal_Verdaux *dst)
  92 {
  93   dst->vda_name = H_GET_32 (abfd, src->vda_name);
  94   dst->vda_next = H_GET_32 (abfd, src->vda_next);
  95 }
  96
  97 /* Swap out a Verdaux structure.  */
  98
  99 void
 100 _bfd_elf_swap_verdaux_out (bfd *abfd,
 101                            const Elf_Internal_Verdaux *src,
 102                            Elf_External_Verdaux *dst)
 103 {
 104   H_PUT_32 (abfd, src->vda_name, dst->vda_name);
 105   H_PUT_32 (abfd, src->vda_next, dst->vda_next);
 106 }
 107
 108 /* Swap in a Verneed structure.  */
 109
 110 void
 111 _bfd_elf_swap_verneed_in (bfd *abfd,
 112                           const Elf_External_Verneed *src,
 113                           Elf_Internal_Verneed *dst)
 114 {
 115   dst->vn_version = H_GET_16 (abfd, src->vn_version);
 116   dst->vn_cnt     = H_GET_16 (abfd, src->vn_cnt);
 117   dst->vn_file    = H_GET_32 (abfd, src->vn_file);
 118   dst->vn_aux     = H_GET_32 (abfd, src->vn_aux);
 119   dst->vn_next    = H_GET_32 (abfd, src->vn_next);
 120 }
 121
 122 /* Swap out a Verneed structure.  */
 123
 124 void
 125 _bfd_elf_swap_verneed_out (bfd *abfd,
 126                            const Elf_Internal_Verneed *src,
 127                            Elf_External_Verneed *dst)
 128 {
 129   H_PUT_16 (abfd, src->vn_version, dst->vn_version);
 130   H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
 131   H_PUT_32 (abfd, src->vn_file, dst->vn_file);
 132   H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
 133   H_PUT_32 (abfd, src->vn_next, dst->vn_next);
 134 }
 135
 136 /* Swap in a Vernaux structure.  */
 137
 138 void
 139 _bfd_elf_swap_vernaux_in (bfd *abfd,
 140                           const Elf_External_Vernaux *src,
 141                           Elf_Internal_Vernaux *dst)
 142 {
 143   dst->vna_hash  = H_GET_32 (abfd, src->vna_hash);
 144   dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
 145   dst->vna_other = H_GET_16 (abfd, src->vna_other);
 146   dst->vna_name  = H_GET_32 (abfd, src->vna_name);
 147   dst->vna_next  = H_GET_32 (abfd, src->vna_next);
 148 }
 149
 150 /* Swap out a Vernaux structure.  */
 151
 152 void
 153 _bfd_elf_swap_vernaux_out (bfd *abfd,
 154                            const Elf_Internal_Vernaux *src,
 155                            Elf_External_Vernaux *dst)
 156 {
 157   H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
 158   H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
 159   H_PUT_16 (abfd, src->vna_other, dst->vna_other);
 160   H_PUT_32 (abfd, src->vna_name, dst->vna_name);
 161   H_PUT_32 (abfd, src->vna_next, dst->vna_next);
 162 }
 163
 164 /* Swap in a Versym structure.  */
 165
 166 void
 167 _bfd_elf_swap_versym_in (bfd *abfd,
 168                          const Elf_External_Versym *src,
 169                          Elf_Internal_Versym *dst)
 170 {
 171   dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
 172 }
 173
 174 /* Swap out a Versym structure.  */
 175
 176 void
 177 _bfd_elf_swap_versym_out (bfd *abfd,
 178                           const Elf_Internal_Versym *src,
 179                           Elf_External_Versym *dst)
 180 {
 181   H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
 182 }
 183
 184 /* Standard ELF hash function.  Do not change this function; you will
 185    cause invalid hash tables to be generated.  */
 186
 187 unsigned long
 188 bfd_elf_hash (const char *namearg)
 189 {
 190   const unsigned char *name = (const unsigned char *) namearg;
 191   unsigned long h = 0;
 192   unsigned long g;
 193   int ch;
 194
 195   while ((ch = *name++) != '\0')
 196     {
 197       h = (h << 4) + ch;
 198       if ((g = (h & 0xf0000000)) != 0)
 199         {
 200           h ^= g >> 24;
 201           /* The ELF ABI says `h &= ~g', but this is equivalent in
 202              this case and on some machines one insn instead of two.  */
 203           h ^= g;
 204         }
 205     }
 206   return h & 0xffffffff;
 207 }
 208
 209 bfd_boolean
 210 bfd_elf_mkobject (bfd *abfd)
 211 {
 212   /* This just does initialization.  */
 213   /* coff_mkobject zalloc's space for tdata.coff_obj_data ...  */
 214   elf_tdata (abfd) = bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
 215   if (elf_tdata (abfd) == 0)
 216     return FALSE;
 217   /* Since everything is done at close time, do we need any
 218      initialization?  */
 219
 220   return TRUE;
 221 }
 222
 223 bfd_boolean
 224 bfd_elf_mkcorefile (bfd *abfd)
 225 {
 226   /* I think this can be done just like an object file.  */
 227   return bfd_elf_mkobject (abfd);
 228 }
 229
 230 char *
 231 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
 232 {
 233   Elf_Internal_Shdr **i_shdrp;
 234   bfd_byte *shstrtab = NULL;
 235   file_ptr offset;
 236   bfd_size_type shstrtabsize;
 237
 238   i_shdrp = elf_elfsections (abfd);
 239   if (i_shdrp == 0 || i_shdrp[shindex] == 0)
 240     return NULL;
 241
 242   shstrtab = i_shdrp[shindex]->contents;
 243   if (shstrtab == NULL)
 244     {
 245       /* No cached one, attempt to read, and cache what we read.  */
 246       offset = i_shdrp[shindex]->sh_offset;
 247       shstrtabsize = i_shdrp[shindex]->sh_size;
 248
 249       /* Allocate and clear an extra byte at the end, to prevent crashes
 250          in case the string table is not terminated.  */
 251       if (shstrtabsize + 1 == 0
 252           || (shstrtab = bfd_alloc (abfd, shstrtabsize + 1)) == NULL
 253           || bfd_seek (abfd, offset, SEEK_SET) != 0)
 254         shstrtab = NULL;
 255       else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
 256         {
 257           if (bfd_get_error () != bfd_error_system_call)
 258             bfd_set_error (bfd_error_file_truncated);
 259           shstrtab = NULL;
 260         }
 261       else
 262         shstrtab[shstrtabsize] = '\0';
 263       i_shdrp[shindex]->contents = shstrtab;
 264     }
 265   return (char *) shstrtab;
 266 }
 267
 268 char *
 269 bfd_elf_string_from_elf_section (bfd *abfd,
 270                                  unsigned int shindex,
 271                                  unsigned int strindex)
 272 {
 273   Elf_Internal_Shdr *hdr;
 274
 275   if (strindex == 0)
 276     return "";
 277
 278   hdr = elf_elfsections (abfd)[shindex];
 279
 280   if (hdr->contents == NULL
 281       && bfd_elf_get_str_section (abfd, shindex) == NULL)
 282     return NULL;
 283
 284   if (strindex >= hdr->sh_size)
 285     {
 286       unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
 287       (*_bfd_error_handler)
 288         (_("%B: invalid string offset %u >= %lu for section `%s'"),
 289          abfd, strindex, (unsigned long) hdr->sh_size,
 290          (shindex == shstrndx && strindex == hdr->sh_name
 291           ? ".shstrtab"
 292           : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
 293       return "";
 294     }
 295
 296   return ((char *) hdr->contents) + strindex;
 297 }
 298
 299 /* Read and convert symbols to internal format.
 300    SYMCOUNT specifies the number of symbols to read, starting from
 301    symbol SYMOFFSET.  If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
 302    are non-NULL, they are used to store the internal symbols, external
 303    symbols, and symbol section index extensions, respectively.  */
 304
 305 Elf_Internal_Sym *
 306 bfd_elf_get_elf_syms (bfd *ibfd,
 307                       Elf_Internal_Shdr *symtab_hdr,
 308                       size_t symcount,
 309                       size_t symoffset,
 310                       Elf_Internal_Sym *intsym_buf,
 311                       void *extsym_buf,
 312                       Elf_External_Sym_Shndx *extshndx_buf)
 313 {
 314   Elf_Internal_Shdr *shndx_hdr;
 315   void *alloc_ext;
 316   const bfd_byte *esym;
 317   Elf_External_Sym_Shndx *alloc_extshndx;
 318   Elf_External_Sym_Shndx *shndx;
 319   Elf_Internal_Sym *isym;
 320   Elf_Internal_Sym *isymend;
 321   const struct elf_backend_data *bed;
 322   size_t extsym_size;
 323   bfd_size_type amt;
 324   file_ptr pos;
 325
 326   if (symcount == 0)
 327     return intsym_buf;
 328
 329   /* Normal syms might have section extension entries.  */
 330   shndx_hdr = NULL;
 331   if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
 332     shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
 333
 334   /* Read the symbols.  */
 335   alloc_ext = NULL;
 336   alloc_extshndx = NULL;
 337   bed = get_elf_backend_data (ibfd);
 338   extsym_size = bed->s->sizeof_sym;
 339   amt = symcount * extsym_size;
 340   pos = symtab_hdr->sh_offset + symoffset * extsym_size;
 341   if (extsym_buf == NULL)
 342     {
 343       alloc_ext = bfd_malloc2 (symcount, extsym_size);
 344       extsym_buf = alloc_ext;
 345     }
 346   if (extsym_buf == NULL
 347       || bfd_seek (ibfd, pos, SEEK_SET) != 0
 348       || bfd_bread (extsym_buf, amt, ibfd) != amt)
 349     {
 350       intsym_buf = NULL;
 351       goto out;
 352     }
 353
 354   if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
 355     extshndx_buf = NULL;
 356   else
 357     {
 358       amt = symcount * sizeof (Elf_External_Sym_Shndx);
 359       pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
 360       if (extshndx_buf == NULL)
 361         {
 362           alloc_extshndx = bfd_malloc2 (symcount,
 363                                         sizeof (Elf_External_Sym_Shndx));
 364           extshndx_buf = alloc_extshndx;
 365         }
 366       if (extshndx_buf == NULL
 367           || bfd_seek (ibfd, pos, SEEK_SET) != 0
 368           || bfd_bread (extshndx_buf, amt, ibfd) != amt)
 369         {
 370           intsym_buf = NULL;
 371           goto out;
 372         }
 373     }
 374
 375   if (intsym_buf == NULL)
 376     {
 377       intsym_buf = bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
 378       if (intsym_buf == NULL)
 379         goto out;
 380     }
 381
 382   /* Convert the symbols to internal form.  */
 383   isymend = intsym_buf + symcount;
 384   for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
 385        isym < isymend;
 386        esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
 387     (*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym);
 388
 389  out:
 390   if (alloc_ext != NULL)
 391     free (alloc_ext);
 392   if (alloc_extshndx != NULL)
 393     free (alloc_extshndx);
 394
 395   return intsym_buf;
 396 }
 397
 398 /* Look up a symbol name.  */
 399 const char *
 400 bfd_elf_sym_name (bfd *abfd,
 401                   Elf_Internal_Shdr *symtab_hdr,
 402                   Elf_Internal_Sym *isym,
 403                   asection *sym_sec)
 404 {
 405   const char *name;
 406   unsigned int iname = isym->st_name;
 407   unsigned int shindex = symtab_hdr->sh_link;
 408
 409   if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
 410       /* Check for a bogus st_shndx to avoid crashing.  */
 411       && isym->st_shndx < elf_numsections (abfd)
 412       && !(isym->st_shndx >= SHN_LORESERVE && isym->st_shndx <= SHN_HIRESERVE))
 413     {
 414       iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
 415       shindex = elf_elfheader (abfd)->e_shstrndx;
 416     }
 417
 418   name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
 419   if (name == NULL)
 420     name = "(null)";
 421   else if (sym_sec && *name == '\0')
 422     name = bfd_section_name (abfd, sym_sec);
 423
 424   return name;
 425 }
 426
 427 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
 428    sections.  The first element is the flags, the rest are section
 429    pointers.  */
 430
 431 typedef union elf_internal_group {
 432   Elf_Internal_Shdr *shdr;
 433   unsigned int flags;
 434 } Elf_Internal_Group;
 435
 436 /* Return the name of the group signature symbol.  Why isn't the
 437    signature just a string?  */
 438
 439 static const char *
 440 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
 441 {
 442   Elf_Internal_Shdr *hdr;
 443   unsigned char esym[sizeof (Elf64_External_Sym)];
 444   Elf_External_Sym_Shndx eshndx;
 445   Elf_Internal_Sym isym;
 446
 447   /* First we need to ensure the symbol table is available.  Make sure
 448      that it is a symbol table section.  */
 449   hdr = elf_elfsections (abfd) [ghdr->sh_link];
 450   if (hdr->sh_type != SHT_SYMTAB
 451       || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
 452     return NULL;
 453
 454   /* Go read the symbol.  */
 455   hdr = &elf_tdata (abfd)->symtab_hdr;
 456   if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
 457                             &isym, esym, &eshndx) == NULL)
 458     return NULL;
 459
 460   return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
 461 }
 462
 463 /* Set next_in_group list pointer, and group name for NEWSECT.  */
 464
 465 static bfd_boolean
 466 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
 467 {
 468   unsigned int num_group = elf_tdata (abfd)->num_group;
 469
 470   /* If num_group is zero, read in all SHT_GROUP sections.  The count
 471      is set to -1 if there are no SHT_GROUP sections.  */
 472   if (num_group == 0)
 473     {
 474       unsigned int i, shnum;
 475
 476       /* First count the number of groups.  If we have a SHT_GROUP
 477          section with just a flag word (ie. sh_size is 4), ignore it.  */
 478       shnum = elf_numsections (abfd);
 479       num_group = 0;
 480       for (i = 0; i < shnum; i++)
 481         {
 482           Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
 483           if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
 484             num_group += 1;
 485         }
 486
 487       if (num_group == 0)
 488         {
 489           num_group = (unsigned) -1;
 490           elf_tdata (abfd)->num_group = num_group;
 491         }
 492       else
 493         {
 494           /* We keep a list of elf section headers for group sections,
 495              so we can find them quickly.  */
 496           bfd_size_type amt;
 497
 498           elf_tdata (abfd)->num_group = num_group;
 499           elf_tdata (abfd)->group_sect_ptr
 500             = bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
 501           if (elf_tdata (abfd)->group_sect_ptr == NULL)
 502             return FALSE;
 503
 504           num_group = 0;
 505           for (i = 0; i < shnum; i++)
 506             {
 507               Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
 508               if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
 509                 {
 510                   unsigned char *src;
 511                   Elf_Internal_Group *dest;
 512
 513                   /* Add to list of sections.  */
 514                   elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
 515                   num_group += 1;
 516
 517                   /* Read the raw contents.  */
 518                   BFD_ASSERT (sizeof (*dest) >= 4);
 519                   amt = shdr->sh_size * sizeof (*dest) / 4;
 520                   shdr->contents = bfd_alloc2 (abfd, shdr->sh_size,
 521                                                sizeof (*dest) / 4);
 522                   if (shdr->contents == NULL
 523                       || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
 524                       || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
 525                           != shdr->sh_size))
 526                     return FALSE;
 527
 528                   /* Translate raw contents, a flag word followed by an
 529                      array of elf section indices all in target byte order,
 530                      to the flag word followed by an array of elf section
 531                      pointers.  */
 532                   src = shdr->contents + shdr->sh_size;
 533                   dest = (Elf_Internal_Group *) (shdr->contents + amt);
 534                   while (1)
 535                     {
 536                       unsigned int idx;
 537
 538                       src -= 4;
 539                       --dest;
 540                       idx = H_GET_32 (abfd, src);
 541                       if (src == shdr->contents)
 542                         {
 543                           dest->flags = idx;
 544                           if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
 545                             shdr->bfd_section->flags
 546                               |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 547                           break;
 548                         }
 549                       if (idx >= shnum)
 550                         {
 551                           ((*_bfd_error_handler)
 552                            (_("%B: invalid SHT_GROUP entry"), abfd));
 553                           idx = 0;
 554                         }
 555                       dest->shdr = elf_elfsections (abfd)[idx];
 556                     }
 557                 }
 558             }
 559         }
 560     }
 561
 562   if (num_group != (unsigned) -1)
 563     {
 564       unsigned int i;
 565
 566       for (i = 0; i < num_group; i++)
 567         {
 568           Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
 569           Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
 570           unsigned int n_elt = shdr->sh_size / 4;
 571
 572           /* Look through this group's sections to see if current
 573              section is a member.  */
 574           while (--n_elt != 0)
 575             if ((++idx)->shdr == hdr)
 576               {
 577                 asection *s = NULL;
 578
 579                 /* We are a member of this group.  Go looking through
 580                    other members to see if any others are linked via
 581                    next_in_group.  */
 582                 idx = (Elf_Internal_Group *) shdr->contents;
 583                 n_elt = shdr->sh_size / 4;
 584                 while (--n_elt != 0)
 585                   if ((s = (++idx)->shdr->bfd_section) != NULL
 586                       && elf_next_in_group (s) != NULL)
 587                     break;
 588                 if (n_elt != 0)
 589                   {
 590                     /* Snarf the group name from other member, and
 591                        insert current section in circular list.  */
 592                     elf_group_name (newsect) = elf_group_name (s);
 593                     elf_next_in_group (newsect) = elf_next_in_group (s);
 594                     elf_next_in_group (s) = newsect;
 595                   }
 596                 else
 597                   {
 598                     const char *gname;
 599
 600                     gname = group_signature (abfd, shdr);
 601                     if (gname == NULL)
 602                       return FALSE;
 603                     elf_group_name (newsect) = gname;
 604
 605                     /* Start a circular list with one element.  */
 606                     elf_next_in_group (newsect) = newsect;
 607                   }
 608
 609                 /* If the group section has been created, point to the
 610                    new member.  */
 611                 if (shdr->bfd_section != NULL)
 612                   elf_next_in_group (shdr->bfd_section) = newsect;
 613
 614                 i = num_group - 1;
 615                 break;
 616               }
 617         }
 618     }
 619
 620   if (elf_group_name (newsect) == NULL)
 621     {
 622       (*_bfd_error_handler) (_("%B: no group info for section %A"),
 623                              abfd, newsect);
 624     }
 625   return TRUE;
 626 }
 627
 628 bfd_boolean
 629 _bfd_elf_setup_sections (bfd *abfd)
 630 {
 631   unsigned int i;
 632   unsigned int num_group = elf_tdata (abfd)->num_group;
 633   bfd_boolean result = TRUE;
 634   asection *s;
 635
 636   /* Process SHF_LINK_ORDER.  */
 637   for (s = abfd->sections; s != NULL; s = s->next)
 638     {
 639       Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
 640       if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
 641         {
 642           unsigned int elfsec = this_hdr->sh_link;
 643           /* FIXME: The old Intel compiler and old strip/objcopy may
 644              not set the sh_link or sh_info fields.  Hence we could
 645              get the situation where elfsec is 0.  */
 646           if (elfsec == 0)
 647             {
 648               const struct elf_backend_data *bed
 649                 = get_elf_backend_data (abfd);
 650               if (bed->link_order_error_handler)
 651                 bed->link_order_error_handler
 652                   (_("%B: warning: sh_link not set for section `%A'"),
 653                    abfd, s);
 654             }
 655           else
 656             {
 657               asection *link;
 658
 659               this_hdr = elf_elfsections (abfd)[elfsec];
 660
 661               /* PR 1991, 2008:
 662                  Some strip/objcopy may leave an incorrect value in
 663                  sh_link.  We don't want to proceed.  */
 664               link = this_hdr->bfd_section;
 665               if (link == NULL)
 666                 {
 667                   (*_bfd_error_handler)
 668                     (_("%B: sh_link [%d] in section `%A' is incorrect"),
 669                      s->owner, s, elfsec);
 670                   result = FALSE;
 671                 }
 672
 673               elf_linked_to_section (s) = link;
 674             }
 675         }
 676     }
 677
 678   /* Process section groups.  */
 679   if (num_group == (unsigned) -1)
 680     return result;
 681
 682   for (i = 0; i < num_group; i++)
 683     {
 684       Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
 685       Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
 686       unsigned int n_elt = shdr->sh_size / 4;
 687
 688       while (--n_elt != 0)
 689         if ((++idx)->shdr->bfd_section)
 690           elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
 691         else if (idx->shdr->sh_type == SHT_RELA
 692                  || idx->shdr->sh_type == SHT_REL)
 693           /* We won't include relocation sections in section groups in
 694              output object files. We adjust the group section size here
 695              so that relocatable link will work correctly when
 696              relocation sections are in section group in input object
 697              files.  */
 698           shdr->bfd_section->size -= 4;
 699         else
 700           {
 701             /* There are some unknown sections in the group.  */
 702             (*_bfd_error_handler)
 703               (_("%B: unknown [%d] section `%s' in group [%s]"),
 704                abfd,
 705                (unsigned int) idx->shdr->sh_type,
 706                bfd_elf_string_from_elf_section (abfd,
 707                                                 (elf_elfheader (abfd)
 708                                                  ->e_shstrndx),
 709                                                 idx->shdr->sh_name),
 710                shdr->bfd_section->name);
 711             result = FALSE;
 712           }
 713     }
 714   return result;
 715 }
 716
 717 bfd_boolean
 718 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
 719 {
 720   return elf_next_in_group (sec) != NULL;
 721 }
 722
 723 /* Make a BFD section from an ELF section.  We store a pointer to the
 724    BFD section in the bfd_section field of the header.  */
 725
 726 bfd_boolean
 727 _bfd_elf_make_section_from_shdr (bfd *abfd,
 728                                  Elf_Internal_Shdr *hdr,
 729                                  const char *name,
 730                                  int shindex)
 731 {
 732   asection *newsect;
 733   flagword flags;
 734   const struct elf_backend_data *bed;
 735
 736   if (hdr->bfd_section != NULL)
 737     {
 738       BFD_ASSERT (strcmp (name,
 739                           bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
 740       return TRUE;
 741     }
 742
 743   newsect = bfd_make_section_anyway (abfd, name);
 744   if (newsect == NULL)
 745     return FALSE;
 746
 747   hdr->bfd_section = newsect;
 748   elf_section_data (newsect)->this_hdr = *hdr;
 749   elf_section_data (newsect)->this_idx = shindex;
 750
 751   /* Always use the real type/flags.  */
 752   elf_section_type (newsect) = hdr->sh_type;
 753   elf_section_flags (newsect) = hdr->sh_flags;
 754
 755   newsect->filepos = hdr->sh_offset;
 756
 757   if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
 758       || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
 759       || ! bfd_set_section_alignment (abfd, newsect,
 760                                       bfd_log2 ((bfd_vma) hdr->sh_addralign)))
 761     return FALSE;
 762
 763   flags = SEC_NO_FLAGS;
 764   if (hdr->sh_type != SHT_NOBITS)
 765     flags |= SEC_HAS_CONTENTS;
 766   if (hdr->sh_type == SHT_GROUP)
 767     flags |= SEC_GROUP | SEC_EXCLUDE;
 768   if ((hdr->sh_flags & SHF_ALLOC) != 0)
 769     {
 770       flags |= SEC_ALLOC;
 771       if (hdr->sh_type != SHT_NOBITS)
 772         flags |= SEC_LOAD;
 773     }
 774   if ((hdr->sh_flags & SHF_WRITE) == 0)
 775     flags |= SEC_READONLY;
 776   if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
 777     flags |= SEC_CODE;
 778   else if ((flags & SEC_LOAD) != 0)
 779     flags |= SEC_DATA;
 780   if ((hdr->sh_flags & SHF_MERGE) != 0)
 781     {
 782       flags |= SEC_MERGE;
 783       newsect->entsize = hdr->sh_entsize;
 784       if ((hdr->sh_flags & SHF_STRINGS) != 0)
 785         flags |= SEC_STRINGS;
 786     }
 787   if (hdr->sh_flags & SHF_GROUP)
 788     if (!setup_group (abfd, hdr, newsect))
 789       return FALSE;
 790   if ((hdr->sh_flags & SHF_TLS) != 0)
 791     flags |= SEC_THREAD_LOCAL;
 792
 793   if ((flags & SEC_ALLOC) == 0)
 794     {
 795       /* The debugging sections appear to be recognized only by name,
 796          not any sort of flag.  Their SEC_ALLOC bits are cleared.  */
 797       static const struct
 798         {
 799           const char *name;
 800           int len;
 801         } debug_sections [] =
 802         {
 803           { "debug",             5  },  /* 'd' */
 804           { NULL,                0  },  /* 'e' */
 805           { NULL,                0  },  /* 'f' */
 806           { "gnu.linkonce.wi.", 17 },   /* 'g' */
 807           { NULL,                0  },  /* 'h' */
 808           { NULL,                0  },  /* 'i' */
 809           { NULL,                0  },  /* 'j' */
 810           { NULL,                0  },  /* 'k' */
 811           { "line",              4  },  /* 'l' */
 812           { NULL,                0  },  /* 'm' */
 813           { NULL,                0  },  /* 'n' */
 814           { NULL,                0  },  /* 'o' */
 815           { NULL,                0  },  /* 'p' */
 816           { NULL,                0  },  /* 'q' */
 817           { NULL,                0  },  /* 'r' */
 818           { "stab",              4  }   /* 's' */
 819         };
 820
 821       if (name [0] == '.')
 822         {
 823           int i = name [1] - 'd';
 824           if (i >= 0
 825               && i < (int) ARRAY_SIZE (debug_sections)
 826               && debug_sections [i].name != NULL
 827               && strncmp (&name [1], debug_sections [i].name,
 828                           debug_sections [i].len) == 0)
 829             flags |= SEC_DEBUGGING;
 830         }
 831     }
 832
 833   /* As a GNU extension, if the name begins with .gnu.linkonce, we
 834      only link a single copy of the section.  This is used to support
 835      g++.  g++ will emit each template expansion in its own section.
 836      The symbols will be defined as weak, so that multiple definitions
 837      are permitted.  The GNU linker extension is to actually discard
 838      all but one of the sections.  */
 839   if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
 840       && elf_next_in_group (newsect) == NULL)
 841     flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 842
 843   bed = get_elf_backend_data (abfd);
 844   if (bed->elf_backend_section_flags)
 845     if (! bed->elf_backend_section_flags (&flags, hdr))
 846       return FALSE;
 847
 848   if (! bfd_set_section_flags (abfd, newsect, flags))
 849     return FALSE;
 850
 851   if ((flags & SEC_ALLOC) != 0)
 852     {
 853       Elf_Internal_Phdr *phdr;
 854       unsigned int i;
 855
 856       /* Look through the phdrs to see if we need to adjust the lma.
 857          If all the p_paddr fields are zero, we ignore them, since
 858          some ELF linkers produce such output.  */
 859       phdr = elf_tdata (abfd)->phdr;
 860       for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
 861         {
 862           if (phdr->p_paddr != 0)
 863             break;
 864         }
 865       if (i < elf_elfheader (abfd)->e_phnum)
 866         {
 867           phdr = elf_tdata (abfd)->phdr;
 868           for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
 869             {
 870               /* This section is part of this segment if its file
 871                  offset plus size lies within the segment's memory
 872                  span and, if the section is loaded, the extent of the
 873                  loaded data lies within the extent of the segment.
 874
 875                  Note - we used to check the p_paddr field as well, and
 876                  refuse to set the LMA if it was 0.  This is wrong
 877                  though, as a perfectly valid initialised segment can
 878                  have a p_paddr of zero.  Some architectures, eg ARM,
 879                  place special significance on the address 0 and
 880                  executables need to be able to have a segment which
 881                  covers this address.  */
 882               if (phdr->p_type == PT_LOAD
 883                   && (bfd_vma) hdr->sh_offset >= phdr->p_offset
 884                   && (hdr->sh_offset + hdr->sh_size
 885                       <= phdr->p_offset + phdr->p_memsz)
 886                   && ((flags & SEC_LOAD) == 0
 887                       || (hdr->sh_offset + hdr->sh_size
 888                           <= phdr->p_offset + phdr->p_filesz)))
 889                 {
 890                   if ((flags & SEC_LOAD) == 0)
 891                     newsect->lma = (phdr->p_paddr
 892                                     + hdr->sh_addr - phdr->p_vaddr);
 893                   else
 894                     /* We used to use the same adjustment for SEC_LOAD
 895                        sections, but that doesn't work if the segment
 896                        is packed with code from multiple VMAs.
 897                        Instead we calculate the section LMA based on
 898                        the segment LMA.  It is assumed that the
 899                        segment will contain sections with contiguous
 900                        LMAs, even if the VMAs are not.  */
 901                     newsect->lma = (phdr->p_paddr
 902                                     + hdr->sh_offset - phdr->p_offset);
 903
 904                   /* With contiguous segments, we can't tell from file
 905                      offsets whether a section with zero size should
 906                      be placed at the end of one segment or the
 907                      beginning of the next.  Decide based on vaddr.  */
 908                   if (hdr->sh_addr >= phdr->p_vaddr
 909                       && (hdr->sh_addr + hdr->sh_size
 910                           <= phdr->p_vaddr + phdr->p_memsz))
 911                     break;
 912                 }
 913             }
 914         }
 915     }
 916
 917   return TRUE;
 918 }
 919
 920 /*
 921 INTERNAL_FUNCTION
 922         bfd_elf_find_section
 923
 924 SYNOPSIS
 925         struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
 926
 927 DESCRIPTION
 928         Helper functions for GDB to locate the string tables.
 929         Since BFD hides string tables from callers, GDB needs to use an
 930         internal hook to find them.  Sun's .stabstr, in particular,
 931         isn't even pointed to by the .stab section, so ordinary
 932         mechanisms wouldn't work to find it, even if we had some.
 933 */
 934
 935 struct elf_internal_shdr *
 936 bfd_elf_find_section (bfd *abfd, char *name)
 937 {
 938   Elf_Internal_Shdr **i_shdrp;
 939   char *shstrtab;
 940   unsigned int max;
 941   unsigned int i;
 942
 943   i_shdrp = elf_elfsections (abfd);
 944   if (i_shdrp != NULL)
 945     {
 946       shstrtab = bfd_elf_get_str_section (abfd,
 947                                           elf_elfheader (abfd)->e_shstrndx);
 948       if (shstrtab != NULL)
 949         {
 950           max = elf_numsections (abfd);
 951           for (i = 1; i < max; i++)
 952             if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
 953               return i_shdrp[i];
 954         }
 955     }
 956   return 0;
 957 }
 958
 959 const char *const bfd_elf_section_type_names[] = {
 960   "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
 961   "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
 962   "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
 963 };
 964
 965 /* ELF relocs are against symbols.  If we are producing relocatable
 966    output, and the reloc is against an external symbol, and nothing
 967    has given us any additional addend, the resulting reloc will also
 968    be against the same symbol.  In such a case, we don't want to
 969    change anything about the way the reloc is handled, since it will
 970    all be done at final link time.  Rather than put special case code
 971    into bfd_perform_relocation, all the reloc types use this howto
 972    function.  It just short circuits the reloc if producing
 973    relocatable output against an external symbol.  */
 974
 975 bfd_reloc_status_type
 976 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 977                        arelent *reloc_entry,
 978                        asymbol *symbol,
 979                        void *data ATTRIBUTE_UNUSED,
 980                        asection *input_section,
 981                        bfd *output_bfd,
 982                        char **error_message ATTRIBUTE_UNUSED)
 983 {
 984   if (output_bfd != NULL
 985       && (symbol->flags & BSF_SECTION_SYM) == 0
 986       && (! reloc_entry->howto->partial_inplace
 987           || reloc_entry->addend == 0))
 988     {
 989       reloc_entry->address += input_section->output_offset;
 990       return bfd_reloc_ok;
 991     }
 992
 993   return bfd_reloc_continue;
 994 }
 995 \f
 996 /* Make sure sec_info_type is cleared if sec_info is cleared too.  */
 997
 998 static void
 999 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
1000                             asection *sec)
1001 {
1002   BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
1003   sec->sec_info_type = ELF_INFO_TYPE_NONE;
1004 }
1005
1006 /* Finish SHF_MERGE section merging.  */
1007
1008 bfd_boolean
1009 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
1010 {
1011   bfd *ibfd;
1012   asection *sec;
1013
1014   if (!is_elf_hash_table (info->hash))
1015     return FALSE;
1016
1017   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1018     if ((ibfd->flags & DYNAMIC) == 0)
1019       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
1020         if ((sec->flags & SEC_MERGE) != 0
1021             && !bfd_is_abs_section (sec->output_section))
1022           {
1023             struct bfd_elf_section_data *secdata;
1024
1025             secdata = elf_section_data (sec);
1026             if (! _bfd_add_merge_section (abfd,
1027                                           &elf_hash_table (info)->merge_info,
1028                                           sec, &secdata->sec_info))
1029               return FALSE;
1030             else if (secdata->sec_info)
1031               sec->sec_info_type = ELF_INFO_TYPE_MERGE;
1032           }
1033
1034   if (elf_hash_table (info)->merge_info != NULL)
1035     _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
1036                          merge_sections_remove_hook);
1037   return TRUE;
1038 }
1039
1040 void
1041 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
1042 {
1043   sec->output_section = bfd_abs_section_ptr;
1044   sec->output_offset = sec->vma;
1045   if (!is_elf_hash_table (info->hash))
1046     return;
1047
1048   sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
1049 }
1050 \f
1051 /* Copy the program header and other data from one object module to
1052    another.  */
1053
1054 bfd_boolean
1055 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1056 {
1057   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1058       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1059     return TRUE;
1060
1061   BFD_ASSERT (!elf_flags_init (obfd)
1062               || (elf_elfheader (obfd)->e_flags
1063                   == elf_elfheader (ibfd)->e_flags));
1064
1065   elf_gp (obfd) = elf_gp (ibfd);
1066   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1067   elf_flags_init (obfd) = TRUE;
1068   return TRUE;
1069 }
1070
1071 /* Print out the program headers.  */
1072
1073 bfd_boolean
1074 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1075 {
1076   FILE *f = farg;
1077   Elf_Internal_Phdr *p;
1078   asection *s;
1079   bfd_byte *dynbuf = NULL;
1080
1081   p = elf_tdata (abfd)->phdr;
1082   if (p != NULL)
1083     {
1084       unsigned int i, c;
1085
1086       fprintf (f, _("\nProgram Header:\n"));
1087       c = elf_elfheader (abfd)->e_phnum;
1088       for (i = 0; i < c; i++, p++)
1089         {
1090           const char *pt;
1091           char buf[20];
1092
1093           switch (p->p_type)
1094             {
1095             case PT_NULL: pt = "NULL"; break;
1096             case PT_LOAD: pt = "LOAD"; break;
1097             case PT_DYNAMIC: pt = "DYNAMIC"; break;
1098             case PT_INTERP: pt = "INTERP"; break;
1099             case PT_NOTE: pt = "NOTE"; break;
1100             case PT_SHLIB: pt = "SHLIB"; break;
1101             case PT_PHDR: pt = "PHDR"; break;
1102             case PT_TLS: pt = "TLS"; break;
1103             case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1104             case PT_GNU_STACK: pt = "STACK"; break;
1105             case PT_GNU_RELRO: pt = "RELRO"; break;
1106             default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
1107             }
1108           fprintf (f, "%8s off    0x", pt);
1109           bfd_fprintf_vma (abfd, f, p->p_offset);
1110           fprintf (f, " vaddr 0x");
1111           bfd_fprintf_vma (abfd, f, p->p_vaddr);
1112           fprintf (f, " paddr 0x");
1113           bfd_fprintf_vma (abfd, f, p->p_paddr);
1114           fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1115           fprintf (f, "         filesz 0x");
1116           bfd_fprintf_vma (abfd, f, p->p_filesz);
1117           fprintf (f, " memsz 0x");
1118           bfd_fprintf_vma (abfd, f, p->p_memsz);
1119           fprintf (f, " flags %c%c%c",
1120                    (p->p_flags & PF_R) != 0 ? 'r' : '-',
1121                    (p->p_flags & PF_W) != 0 ? 'w' : '-',
1122                    (p->p_flags & PF_X) != 0 ? 'x' : '-');
1123           if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1124             fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1125           fprintf (f, "\n");
1126         }
1127     }
1128
1129   s = bfd_get_section_by_name (abfd, ".dynamic");
1130   if (s != NULL)
1131     {
1132       int elfsec;
1133       unsigned long shlink;
1134       bfd_byte *extdyn, *extdynend;
1135       size_t extdynsize;
1136       void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1137
1138       fprintf (f, _("\nDynamic Section:\n"));
1139
1140       if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1141         goto error_return;
1142
1143       elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1144       if (elfsec == -1)
1145         goto error_return;
1146       shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1147
1148       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1149       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1150
1151       extdyn = dynbuf;
1152       extdynend = extdyn + s->size;
1153       for (; extdyn < extdynend; extdyn += extdynsize)
1154         {
1155           Elf_Internal_Dyn dyn;
1156           const char *name;
1157           char ab[20];
1158           bfd_boolean stringp;
1159
1160           (*swap_dyn_in) (abfd, extdyn, &dyn);
1161
1162           if (dyn.d_tag == DT_NULL)
1163             break;
1164
1165           stringp = FALSE;
1166           switch (dyn.d_tag)
1167             {
1168             default:
1169               sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1170               name = ab;
1171               break;
1172
1173             case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1174             case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1175             case DT_PLTGOT: name = "PLTGOT"; break;
1176             case DT_HASH: name = "HASH"; break;
1177             case DT_STRTAB: name = "STRTAB"; break;
1178             case DT_SYMTAB: name = "SYMTAB"; break;
1179             case DT_RELA: name = "RELA"; break;
1180             case DT_RELASZ: name = "RELASZ"; break;
1181             case DT_RELAENT: name = "RELAENT"; break;
1182             case DT_STRSZ: name = "STRSZ"; break;
1183             case DT_SYMENT: name = "SYMENT"; break;
1184             case DT_INIT: name = "INIT"; break;
1185             case DT_FINI: name = "FINI"; break;
1186             case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1187             case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1188             case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1189             case DT_REL: name = "REL"; break;
1190             case DT_RELSZ: name = "RELSZ"; break;
1191             case DT_RELENT: name = "RELENT"; break;
1192             case DT_PLTREL: name = "PLTREL"; break;
1193             case DT_DEBUG: name = "DEBUG"; break;
1194             case DT_TEXTREL: name = "TEXTREL"; break;
1195             case DT_JMPREL: name = "JMPREL"; break;
1196             case DT_BIND_NOW: name = "BIND_NOW"; break;
1197             case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1198             case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1199             case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1200             case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1201             case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1202             case DT_FLAGS: name = "FLAGS"; break;
1203             case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1204             case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1205             case DT_CHECKSUM: name = "CHECKSUM"; break;
1206             case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1207             case DT_MOVEENT: name = "MOVEENT"; break;
1208             case DT_MOVESZ: name = "MOVESZ"; break;
1209             case DT_FEATURE: name = "FEATURE"; break;
1210             case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1211             case DT_SYMINSZ: name = "SYMINSZ"; break;
1212             case DT_SYMINENT: name = "SYMINENT"; break;
1213             case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1214             case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1215             case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1216             case DT_PLTPAD: name = "PLTPAD"; break;
1217             case DT_MOVETAB: name = "MOVETAB"; break;
1218             case DT_SYMINFO: name = "SYMINFO"; break;
1219             case DT_RELACOUNT: name = "RELACOUNT"; break;
1220             case DT_RELCOUNT: name = "RELCOUNT"; break;
1221             case DT_FLAGS_1: name = "FLAGS_1"; break;
1222             case DT_VERSYM: name = "VERSYM"; break;
1223             case DT_VERDEF: name = "VERDEF"; break;
1224             case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1225             case DT_VERNEED: name = "VERNEED"; break;
1226             case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1227             case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1228             case DT_USED: name = "USED"; break;
1229             case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1230             }
1231
1232           fprintf (f, "  %-11s ", name);
1233           if (! stringp)
1234             fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1235           else
1236             {
1237               const char *string;
1238               unsigned int tagv = dyn.d_un.d_val;
1239
1240               string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1241               if (string == NULL)
1242                 goto error_return;
1243               fprintf (f, "%s", string);
1244             }
1245           fprintf (f, "\n");
1246         }
1247
1248       free (dynbuf);
1249       dynbuf = NULL;
1250     }
1251
1252   if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1253       || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1254     {
1255       if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1256         return FALSE;
1257     }
1258
1259   if (elf_dynverdef (abfd) != 0)
1260     {
1261       Elf_Internal_Verdef *t;
1262
1263       fprintf (f, _("\nVersion definitions:\n"));
1264       for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1265         {
1266           fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1267                    t->vd_flags, t->vd_hash,
1268                    t->vd_nodename ? t->vd_nodename : "<corrupt>");
1269           if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1270             {
1271               Elf_Internal_Verdaux *a;
1272
1273               fprintf (f, "\t");
1274               for (a = t->vd_auxptr->vda_nextptr;
1275                    a != NULL;
1276                    a = a->vda_nextptr)
1277                 fprintf (f, "%s ",
1278                          a->vda_nodename ? a->vda_nodename : "<corrupt>");
1279               fprintf (f, "\n");
1280             }
1281         }
1282     }
1283
1284   if (elf_dynverref (abfd) != 0)
1285     {
1286       Elf_Internal_Verneed *t;
1287
1288       fprintf (f, _("\nVersion References:\n"));
1289       for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1290         {
1291           Elf_Internal_Vernaux *a;
1292
1293           fprintf (f, _("  required from %s:\n"),
1294                    t->vn_filename ? t->vn_filename : "<corrupt>");
1295           for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1296             fprintf (f, "    0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1297                      a->vna_flags, a->vna_other,
1298                      a->vna_nodename ? a->vna_nodename : "<corrupt>");
1299         }
1300     }
1301
1302   return TRUE;
1303
1304  error_return:
1305   if (dynbuf != NULL)
1306     free (dynbuf);
1307   return FALSE;
1308 }
1309
1310 /* Display ELF-specific fields of a symbol.  */
1311
1312 void
1313 bfd_elf_print_symbol (bfd *abfd,
1314                       void *filep,
1315                       asymbol *symbol,
1316                       bfd_print_symbol_type how)
1317 {
1318   FILE *file = filep;
1319   switch (how)
1320     {
1321     case bfd_print_symbol_name:
1322       fprintf (file, "%s", symbol->name);
1323       break;
1324     case bfd_print_symbol_more:
1325       fprintf (file, "elf ");
1326       bfd_fprintf_vma (abfd, file, symbol->value);
1327       fprintf (file, " %lx", (long) symbol->flags);
1328       break;
1329     case bfd_print_symbol_all:
1330       {
1331         const char *section_name;
1332         const char *name = NULL;
1333         const struct elf_backend_data *bed;
1334         unsigned char st_other;
1335         bfd_vma val;
1336
1337         section_name = symbol->section ? symbol->section->name : "(*none*)";
1338
1339         bed = get_elf_backend_data (abfd);
1340         if (bed->elf_backend_print_symbol_all)
1341           name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1342
1343         if (name == NULL)
1344           {
1345             name = symbol->name;
1346             bfd_print_symbol_vandf (abfd, file, symbol);
1347           }
1348
1349         fprintf (file, " %s\t", section_name);
1350         /* Print the "other" value for a symbol.  For common symbols,
1351            we've already printed the size; now print the alignment.
1352            For other symbols, we have no specified alignment, and
1353            we've printed the address; now print the size.  */
1354         if (bfd_is_com_section (symbol->section))
1355           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1356         else
1357           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1358         bfd_fprintf_vma (abfd, file, val);
1359
1360         /* If we have version information, print it.  */
1361         if (elf_tdata (abfd)->dynversym_section != 0
1362             && (elf_tdata (abfd)->dynverdef_section != 0
1363                 || elf_tdata (abfd)->dynverref_section != 0))
1364           {
1365             unsigned int vernum;
1366             const char *version_string;
1367
1368             vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1369
1370             if (vernum == 0)
1371               version_string = "";
1372             else if (vernum == 1)
1373               version_string = "Base";
1374             else if (vernum <= elf_tdata (abfd)->cverdefs)
1375               version_string =
1376                 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1377             else
1378               {
1379                 Elf_Internal_Verneed *t;
1380
1381                 version_string = "";
1382                 for (t = elf_tdata (abfd)->verref;
1383                      t != NULL;
1384                      t = t->vn_nextref)
1385                   {
1386                     Elf_Internal_Vernaux *a;
1387
1388                     for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1389                       {
1390                         if (a->vna_other == vernum)
1391                           {
1392                             version_string = a->vna_nodename;
1393                             break;
1394                           }
1395                       }
1396                   }
1397               }
1398
1399             if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1400               fprintf (file, "  %-11s", version_string);
1401             else
1402               {
1403                 int i;
1404
1405                 fprintf (file, " (%s)", version_string);
1406                 for (i = 10 - strlen (version_string); i > 0; --i)
1407                   putc (' ', file);
1408               }
1409           }
1410
1411         /* If the st_other field is not zero, print it.  */
1412         st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1413
1414         switch (st_other)
1415           {
1416           case 0: break;
1417           case STV_INTERNAL:  fprintf (file, " .internal");  break;
1418           case STV_HIDDEN:    fprintf (file, " .hidden");    break;
1419           case STV_PROTECTED: fprintf (file, " .protected"); break;
1420           default:
1421             /* Some other non-defined flags are also present, so print
1422                everything hex.  */
1423             fprintf (file, " 0x%02x", (unsigned int) st_other);
1424           }
1425
1426         fprintf (file, " %s", name);
1427       }
1428       break;
1429     }
1430 }
1431 \f
1432 /* Create an entry in an ELF linker hash table.  */
1433
1434 struct bfd_hash_entry *
1435 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1436                             struct bfd_hash_table *table,
1437                             const char *string)
1438 {
1439   /* Allocate the structure if it has not already been allocated by a
1440      subclass.  */
1441   if (entry == NULL)
1442     {
1443       entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1444       if (entry == NULL)
1445         return entry;
1446     }
1447
1448   /* Call the allocation method of the superclass.  */
1449   entry = _bfd_link_hash_newfunc (entry, table, string);
1450   if (entry != NULL)
1451     {
1452       struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1453       struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1454
1455       /* Set local fields.  */
1456       ret->indx = -1;
1457       ret->dynindx = -1;
1458       ret->got = htab->init_got_refcount;
1459       ret->plt = htab->init_plt_refcount;
1460       memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
1461                               - offsetof (struct elf_link_hash_entry, size)));
1462       /* Assume that we have been called by a non-ELF symbol reader.
1463          This flag is then reset by the code which reads an ELF input
1464          file.  This ensures that a symbol created by a non-ELF symbol
1465          reader will have the flag set correctly.  */
1466       ret->non_elf = 1;
1467     }
1468
1469   return entry;
1470 }
1471
1472 /* Copy data from an indirect symbol to its direct symbol, hiding the
1473    old indirect symbol.  Also used for copying flags to a weakdef.  */
1474
1475 void
1476 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
1477                                   struct elf_link_hash_entry *dir,
1478                                   struct elf_link_hash_entry *ind)
1479 {
1480   struct elf_link_hash_table *htab;
1481
1482   /* Copy down any references that we may have already seen to the
1483      symbol which just became indirect.  */
1484
1485   dir->ref_dynamic |= ind->ref_dynamic;
1486   dir->ref_regular |= ind->ref_regular;
1487   dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1488   dir->non_got_ref |= ind->non_got_ref;
1489   dir->needs_plt |= ind->needs_plt;
1490   dir->pointer_equality_needed |= ind->pointer_equality_needed;
1491
1492   if (ind->root.type != bfd_link_hash_indirect)
1493     return;
1494
1495   /* Copy over the global and procedure linkage table refcount entries.
1496      These may have been already set up by a check_relocs routine.  */
1497   htab = elf_hash_table (info);
1498   if (ind->got.refcount > htab->init_got_refcount.refcount)
1499     {
1500       if (dir->got.refcount < 0)
1501         dir->got.refcount = 0;
1502       dir->got.refcount += ind->got.refcount;
1503       ind->got.refcount = htab->init_got_refcount.refcount;
1504     }
1505
1506   if (ind->plt.refcount > htab->init_plt_refcount.refcount)
1507     {
1508       if (dir->plt.refcount < 0)
1509         dir->plt.refcount = 0;
1510       dir->plt.refcount += ind->plt.refcount;
1511       ind->plt.refcount = htab->init_plt_refcount.refcount;
1512     }
1513
1514   if (ind->dynindx != -1)
1515     {
1516       if (dir->dynindx != -1)
1517         _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
1518       dir->dynindx = ind->dynindx;
1519       dir->dynstr_index = ind->dynstr_index;
1520       ind->dynindx = -1;
1521       ind->dynstr_index = 0;
1522     }
1523 }
1524
1525 void
1526 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
1527                                 struct elf_link_hash_entry *h,
1528                                 bfd_boolean force_local)
1529 {
1530   h->plt = elf_hash_table (info)->init_plt_offset;
1531   h->needs_plt = 0;
1532   if (force_local)
1533     {
1534       h->forced_local = 1;
1535       if (h->dynindx != -1)
1536         {
1537           h->dynindx = -1;
1538           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1539                                   h->dynstr_index);
1540         }
1541     }
1542 }
1543
1544 /* Initialize an ELF linker hash table.  */
1545
1546 bfd_boolean
1547 _bfd_elf_link_hash_table_init
1548   (struct elf_link_hash_table *table,
1549    bfd *abfd,
1550    struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
1551                                       struct bfd_hash_table *,
1552                                       const char *))
1553 {
1554   bfd_boolean ret;
1555   int can_refcount = get_elf_backend_data (abfd)->can_refcount;
1556
1557   table->dynamic_sections_created = FALSE;
1558   table->dynobj = NULL;
1559   table->init_got_refcount.refcount = can_refcount - 1;
1560   table->init_plt_refcount.refcount = can_refcount - 1;
1561   table->init_got_offset.offset = -(bfd_vma) 1;
1562   table->init_plt_offset.offset = -(bfd_vma) 1;
1563   /* The first dynamic symbol is a dummy.  */
1564   table->dynsymcount = 1;
1565   table->dynstr = NULL;
1566   table->bucketcount = 0;
1567   table->needed = NULL;
1568   table->hgot = NULL;
1569   table->merge_info = NULL;
1570   memset (&table->stab_info, 0, sizeof (table->stab_info));
1571   memset (&table->eh_info, 0, sizeof (table->eh_info));
1572   table->dynlocal = NULL;
1573   table->runpath = NULL;
1574   table->tls_sec = NULL;
1575   table->tls_size = 0;
1576   table->loaded = NULL;
1577   table->is_relocatable_executable = FALSE;
1578
1579   ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc);
1580   table->root.type = bfd_link_elf_hash_table;
1581
1582   return ret;
1583 }
1584
1585 /* Create an ELF linker hash table.  */
1586
1587 struct bfd_link_hash_table *
1588 _bfd_elf_link_hash_table_create (bfd *abfd)
1589 {
1590   struct elf_link_hash_table *ret;
1591   bfd_size_type amt = sizeof (struct elf_link_hash_table);
1592
1593   ret = bfd_malloc (amt);
1594   if (ret == NULL)
1595     return NULL;
1596
1597   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1598     {
1599       free (ret);
1600       return NULL;
1601     }
1602
1603   return &ret->root;
1604 }
1605
1606 /* This is a hook for the ELF emulation code in the generic linker to
1607    tell the backend linker what file name to use for the DT_NEEDED
1608    entry for a dynamic object.  */
1609
1610 void
1611 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
1612 {
1613   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1614       && bfd_get_format (abfd) == bfd_object)
1615     elf_dt_name (abfd) = name;
1616 }
1617
1618 int
1619 bfd_elf_get_dyn_lib_class (bfd *abfd)
1620 {
1621   int lib_class;
1622   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1623       && bfd_get_format (abfd) == bfd_object)
1624     lib_class = elf_dyn_lib_class (abfd);
1625   else
1626     lib_class = 0;
1627   return lib_class;
1628 }
1629
1630 void
1631 bfd_elf_set_dyn_lib_class (bfd *abfd, int lib_class)
1632 {
1633   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1634       && bfd_get_format (abfd) == bfd_object)
1635     elf_dyn_lib_class (abfd) = lib_class;
1636 }
1637
1638 /* Get the list of DT_NEEDED entries for a link.  This is a hook for
1639    the linker ELF emulation code.  */
1640
1641 struct bfd_link_needed_list *
1642 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
1643                          struct bfd_link_info *info)
1644 {
1645   if (! is_elf_hash_table (info->hash))
1646     return NULL;
1647   return elf_hash_table (info)->needed;
1648 }
1649
1650 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link.  This is a
1651    hook for the linker ELF emulation code.  */
1652
1653 struct bfd_link_needed_list *
1654 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
1655                           struct bfd_link_info *info)
1656 {
1657   if (! is_elf_hash_table (info->hash))
1658     return NULL;
1659   return elf_hash_table (info)->runpath;
1660 }
1661
1662 /* Get the name actually used for a dynamic object for a link.  This
1663    is the SONAME entry if there is one.  Otherwise, it is the string
1664    passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
1665
1666 const char *
1667 bfd_elf_get_dt_soname (bfd *abfd)
1668 {
1669   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1670       && bfd_get_format (abfd) == bfd_object)
1671     return elf_dt_name (abfd);
1672   return NULL;
1673 }
1674
1675 /* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
1676    the ELF linker emulation code.  */
1677
1678 bfd_boolean
1679 bfd_elf_get_bfd_needed_list (bfd *abfd,
1680                              struct bfd_link_needed_list **pneeded)
1681 {
1682   asection *s;
1683   bfd_byte *dynbuf = NULL;
1684   int elfsec;
1685   unsigned long shlink;
1686   bfd_byte *extdyn, *extdynend;
1687   size_t extdynsize;
1688   void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1689
1690   *pneeded = NULL;
1691
1692   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1693       || bfd_get_format (abfd) != bfd_object)
1694     return TRUE;
1695
1696   s = bfd_get_section_by_name (abfd, ".dynamic");
1697   if (s == NULL || s->size == 0)
1698     return TRUE;
1699
1700   if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1701     goto error_return;
1702
1703   elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1704   if (elfsec == -1)
1705     goto error_return;
1706
1707   shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1708
1709   extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1710   swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1711
1712   extdyn = dynbuf;
1713   extdynend = extdyn + s->size;
1714   for (; extdyn < extdynend; extdyn += extdynsize)
1715     {
1716       Elf_Internal_Dyn dyn;
1717
1718       (*swap_dyn_in) (abfd, extdyn, &dyn);
1719
1720       if (dyn.d_tag == DT_NULL)
1721         break;
1722
1723       if (dyn.d_tag == DT_NEEDED)
1724         {
1725           const char *string;
1726           struct bfd_link_needed_list *l;
1727           unsigned int tagv = dyn.d_un.d_val;
1728           bfd_size_type amt;
1729
1730           string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1731           if (string == NULL)
1732             goto error_return;
1733
1734           amt = sizeof *l;
1735           l = bfd_alloc (abfd, amt);
1736           if (l == NULL)
1737             goto error_return;
1738
1739           l->by = abfd;
1740           l->name = string;
1741           l->next = *pneeded;
1742           *pneeded = l;
1743         }
1744     }
1745
1746   free (dynbuf);
1747
1748   return TRUE;
1749
1750  error_return:
1751   if (dynbuf != NULL)
1752     free (dynbuf);
1753   return FALSE;
1754 }
1755 \f
1756 /* Allocate an ELF string table--force the first byte to be zero.  */
1757
1758 struct bfd_strtab_hash *
1759 _bfd_elf_stringtab_init (void)
1760 {
1761   struct bfd_strtab_hash *ret;
1762
1763   ret = _bfd_stringtab_init ();
1764   if (ret != NULL)
1765     {
1766       bfd_size_type loc;
1767
1768       loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1769       BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1770       if (loc == (bfd_size_type) -1)
1771         {
1772           _bfd_stringtab_free (ret);
1773           ret = NULL;
1774         }
1775     }
1776   return ret;
1777 }
1778 \f
1779 /* ELF .o/exec file reading */
1780
1781 /* Create a new bfd section from an ELF section header.  */
1782
1783 bfd_boolean
1784 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1785 {
1786   Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1787   Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1788   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1789   const char *name;
1790
1791   name = bfd_elf_string_from_elf_section (abfd,
1792                                           elf_elfheader (abfd)->e_shstrndx,
1793                                           hdr->sh_name);
1794   if (name == NULL)
1795     return FALSE;
1796
1797   switch (hdr->sh_type)
1798     {
1799     case SHT_NULL:
1800       /* Inactive section. Throw it away.  */
1801       return TRUE;
1802
1803     case SHT_PROGBITS:  /* Normal section with contents.  */
1804     case SHT_NOBITS:    /* .bss section.  */
1805     case SHT_HASH:      /* .hash section.  */
1806     case SHT_NOTE:      /* .note section.  */
1807     case SHT_INIT_ARRAY:        /* .init_array section.  */
1808     case SHT_FINI_ARRAY:        /* .fini_array section.  */
1809     case SHT_PREINIT_ARRAY:     /* .preinit_array section.  */
1810     case SHT_GNU_LIBLIST:       /* .gnu.liblist section.  */
1811       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1812
1813     case SHT_DYNAMIC:   /* Dynamic linking information.  */
1814       if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1815         return FALSE;
1816       if (hdr->sh_link > elf_numsections (abfd)
1817           || elf_elfsections (abfd)[hdr->sh_link] == NULL)
1818         return FALSE;
1819       if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1820         {
1821           Elf_Internal_Shdr *dynsymhdr;
1822
1823           /* The shared libraries distributed with hpux11 have a bogus
1824              sh_link field for the ".dynamic" section.  Find the
1825              string table for the ".dynsym" section instead.  */
1826           if (elf_dynsymtab (abfd) != 0)
1827             {
1828               dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1829               hdr->sh_link = dynsymhdr->sh_link;
1830             }
1831           else
1832             {
1833               unsigned int i, num_sec;
1834
1835               num_sec = elf_numsections (abfd);
1836               for (i = 1; i < num_sec; i++)
1837                 {
1838                   dynsymhdr = elf_elfsections (abfd)[i];
1839                   if (dynsymhdr->sh_type == SHT_DYNSYM)
1840                     {
1841                       hdr->sh_link = dynsymhdr->sh_link;
1842                       break;
1843                     }
1844                 }
1845             }
1846         }
1847       break;
1848
1849     case SHT_SYMTAB:            /* A symbol table */
1850       if (elf_onesymtab (abfd) == shindex)
1851         return TRUE;
1852
1853       if (hdr->sh_entsize != bed->s->sizeof_sym)
1854         return FALSE;
1855       BFD_ASSERT (elf_onesymtab (abfd) == 0);
1856       elf_onesymtab (abfd) = shindex;
1857       elf_tdata (abfd)->symtab_hdr = *hdr;
1858       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1859       abfd->flags |= HAS_SYMS;
1860
1861       /* Sometimes a shared object will map in the symbol table.  If
1862          SHF_ALLOC is set, and this is a shared object, then we also
1863          treat this section as a BFD section.  We can not base the
1864          decision purely on SHF_ALLOC, because that flag is sometimes
1865          set in a relocatable object file, which would confuse the
1866          linker.  */
1867       if ((hdr->sh_flags & SHF_ALLOC) != 0
1868           && (abfd->flags & DYNAMIC) != 0
1869           && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1870                                                 shindex))
1871         return FALSE;
1872
1873       /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1874          can't read symbols without that section loaded as well.  It
1875          is most likely specified by the next section header.  */
1876       if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1877         {
1878           unsigned int i, num_sec;
1879
1880           num_sec = elf_numsections (abfd);
1881           for (i = shindex + 1; i < num_sec; i++)
1882             {
1883               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1884               if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1885                   && hdr2->sh_link == shindex)
1886                 break;
1887             }
1888           if (i == num_sec)
1889             for (i = 1; i < shindex; i++)
1890               {
1891                 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1892                 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1893                     && hdr2->sh_link == shindex)
1894                   break;
1895               }
1896           if (i != shindex)
1897             return bfd_section_from_shdr (abfd, i);
1898         }
1899       return TRUE;
1900
1901     case SHT_DYNSYM:            /* A dynamic symbol table */
1902       if (elf_dynsymtab (abfd) == shindex)
1903         return TRUE;
1904
1905       if (hdr->sh_entsize != bed->s->sizeof_sym)
1906         return FALSE;
1907       BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1908       elf_dynsymtab (abfd) = shindex;
1909       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1910       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1911       abfd->flags |= HAS_SYMS;
1912
1913       /* Besides being a symbol table, we also treat this as a regular
1914          section, so that objcopy can handle it.  */
1915       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1916
1917     case SHT_SYMTAB_SHNDX:      /* Symbol section indices when >64k sections */
1918       if (elf_symtab_shndx (abfd) == shindex)
1919         return TRUE;
1920
1921       BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1922       elf_symtab_shndx (abfd) = shindex;
1923       elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1924       elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1925       return TRUE;
1926
1927     case SHT_STRTAB:            /* A string table */
1928       if (hdr->bfd_section != NULL)
1929         return TRUE;
1930       if (ehdr->e_shstrndx == shindex)
1931         {
1932           elf_tdata (abfd)->shstrtab_hdr = *hdr;
1933           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1934           return TRUE;
1935         }
1936       if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1937         {
1938         symtab_strtab:
1939           elf_tdata (abfd)->strtab_hdr = *hdr;
1940           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1941           return TRUE;
1942         }
1943       if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1944         {
1945         dynsymtab_strtab:
1946           elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1947           hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1948           elf_elfsections (abfd)[shindex] = hdr;
1949           /* We also treat this as a regular section, so that objcopy
1950              can handle it.  */
1951           return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1952                                                   shindex);
1953         }
1954
1955       /* If the string table isn't one of the above, then treat it as a
1956          regular section.  We need to scan all the headers to be sure,
1957          just in case this strtab section appeared before the above.  */
1958       if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1959         {
1960           unsigned int i, num_sec;
1961
1962           num_sec = elf_numsections (abfd);
1963           for (i = 1; i < num_sec; i++)
1964             {
1965               Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1966               if (hdr2->sh_link == shindex)
1967                 {
1968                   /* Prevent endless recursion on broken objects.  */
1969                   if (i == shindex)
1970                     return FALSE;
1971                   if (! bfd_section_from_shdr (abfd, i))
1972                     return FALSE;
1973                   if (elf_onesymtab (abfd) == i)
1974                     goto symtab_strtab;
1975                   if (elf_dynsymtab (abfd) == i)
1976                     goto dynsymtab_strtab;
1977                 }
1978             }
1979         }
1980       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1981
1982     case SHT_REL:
1983     case SHT_RELA:
1984       /* *These* do a lot of work -- but build no sections!  */
1985       {
1986         asection *target_sect;
1987         Elf_Internal_Shdr *hdr2;
1988         unsigned int num_sec = elf_numsections (abfd);
1989
1990         if (hdr->sh_entsize
1991             != (bfd_size_type) (hdr->sh_type == SHT_REL
1992                                 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1993           return FALSE;
1994
1995         /* Check for a bogus link to avoid crashing.  */
1996         if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1997             || hdr->sh_link >= num_sec)
1998           {
1999             ((*_bfd_error_handler)
2000              (_("%B: invalid link %lu for reloc section %s (index %u)"),
2001               abfd, hdr->sh_link, name, shindex));
2002             return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2003                                                     shindex);
2004           }
2005
2006         /* For some incomprehensible reason Oracle distributes
2007            libraries for Solaris in which some of the objects have
2008            bogus sh_link fields.  It would be nice if we could just
2009            reject them, but, unfortunately, some people need to use
2010            them.  We scan through the section headers; if we find only
2011            one suitable symbol table, we clobber the sh_link to point
2012            to it.  I hope this doesn't break anything.  */
2013         if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
2014             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
2015           {
2016             unsigned int scan;
2017             int found;
2018
2019             found = 0;
2020             for (scan = 1; scan < num_sec; scan++)
2021               {
2022                 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
2023                     || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
2024                   {
2025                     if (found != 0)
2026                       {
2027                         found = 0;
2028                         break;
2029                       }
2030                     found = scan;
2031                   }
2032               }
2033             if (found != 0)
2034               hdr->sh_link = found;
2035           }
2036
2037         /* Get the symbol table.  */
2038         if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
2039              || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
2040             && ! bfd_section_from_shdr (abfd, hdr->sh_link))
2041           return FALSE;
2042
2043         /* If this reloc section does not use the main symbol table we
2044            don't treat it as a reloc section.  BFD can't adequately
2045            represent such a section, so at least for now, we don't
2046            try.  We just present it as a normal section.  We also
2047            can't use it as a reloc section if it points to the null
2048            section.  */
2049         if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
2050           return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2051                                                   shindex);
2052
2053         /* Prevent endless recursion on broken objects.  */
2054         if (elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2055             || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
2056           return FALSE;
2057         if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2058           return FALSE;
2059         target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2060         if (target_sect == NULL)
2061           return FALSE;
2062
2063         if ((target_sect->flags & SEC_RELOC) == 0
2064             || target_sect->reloc_count == 0)
2065           hdr2 = &elf_section_data (target_sect)->rel_hdr;
2066         else
2067           {
2068             bfd_size_type amt;
2069             BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
2070             amt = sizeof (*hdr2);
2071             hdr2 = bfd_alloc (abfd, amt);
2072             elf_section_data (target_sect)->rel_hdr2 = hdr2;
2073           }
2074         *hdr2 = *hdr;
2075         elf_elfsections (abfd)[shindex] = hdr2;
2076         target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
2077         target_sect->flags |= SEC_RELOC;
2078         target_sect->relocation = NULL;
2079         target_sect->rel_filepos = hdr->sh_offset;
2080         /* In the section to which the relocations apply, mark whether
2081            its relocations are of the REL or RELA variety.  */
2082         if (hdr->sh_size != 0)
2083           target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
2084         abfd->flags |= HAS_RELOC;
2085         return TRUE;
2086       }
2087       break;
2088
2089     case SHT_GNU_verdef:
2090       elf_dynverdef (abfd) = shindex;
2091       elf_tdata (abfd)->dynverdef_hdr = *hdr;
2092       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2093       break;
2094
2095     case SHT_GNU_versym:
2096       if (hdr->sh_entsize != sizeof (Elf_External_Versym))
2097         return FALSE;
2098       elf_dynversym (abfd) = shindex;
2099       elf_tdata (abfd)->dynversym_hdr = *hdr;
2100       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2101       break;
2102
2103     case SHT_GNU_verneed:
2104       elf_dynverref (abfd) = shindex;
2105       elf_tdata (abfd)->dynverref_hdr = *hdr;
2106       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2107       break;
2108
2109     case SHT_SHLIB:
2110       return TRUE;
2111
2112     case SHT_GROUP:
2113       /* We need a BFD section for objcopy and relocatable linking,
2114          and it's handy to have the signature available as the section
2115          name.  */
2116       if (hdr->sh_entsize != GRP_ENTRY_SIZE)
2117         return FALSE;
2118       name = group_signature (abfd, hdr);
2119       if (name == NULL)
2120         return FALSE;
2121       if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2122         return FALSE;
2123       if (hdr->contents != NULL)
2124         {
2125           Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
2126           unsigned int n_elt = hdr->sh_size / 4;
2127           asection *s;
2128
2129           if (idx->flags & GRP_COMDAT)
2130             hdr->bfd_section->flags
2131               |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2132
2133           /* We try to keep the same section order as it comes in.  */
2134           idx += n_elt;
2135           while (--n_elt != 0)
2136             if ((s = (--idx)->shdr->bfd_section) != NULL
2137                 && elf_next_in_group (s) != NULL)
2138               {
2139                 elf_next_in_group (hdr->bfd_section) = s;
2140                 break;
2141               }
2142         }
2143       break;
2144
2145     default:
2146       /* Check for any processor-specific section types.  */
2147       return bed->elf_backend_section_from_shdr (abfd, hdr, name,
2148                                                  shindex);
2149     }
2150
2151   return TRUE;
2152 }
2153
2154 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2155    Return SEC for sections that have no elf section, and NULL on error.  */
2156
2157 asection *
2158 bfd_section_from_r_symndx (bfd *abfd,
2159                            struct sym_sec_cache *cache,
2160                            asection *sec,
2161                            unsigned long r_symndx)
2162 {
2163   Elf_Internal_Shdr *symtab_hdr;
2164   unsigned char esym[sizeof (Elf64_External_Sym)];
2165   Elf_External_Sym_Shndx eshndx;
2166   Elf_Internal_Sym isym;
2167   unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2168
2169   if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
2170     return cache->sec[ent];
2171
2172   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2173   if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2174                             &isym, esym, &eshndx) == NULL)
2175     return NULL;
2176
2177   if (cache->abfd != abfd)
2178     {
2179       memset (cache->indx, -1, sizeof (cache->indx));
2180       cache->abfd = abfd;
2181     }
2182   cache->indx[ent] = r_symndx;
2183   cache->sec[ent] = sec;
2184   if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
2185       || isym.st_shndx > SHN_HIRESERVE)
2186     {
2187       asection *s;
2188       s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2189       if (s != NULL)
2190         cache->sec[ent] = s;
2191     }
2192   return cache->sec[ent];
2193 }
2194
2195 /* Given an ELF section number, retrieve the corresponding BFD
2196    section.  */
2197
2198 asection *
2199 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
2200 {
2201   if (index >= elf_numsections (abfd))
2202     return NULL;
2203   return elf_elfsections (abfd)[index]->bfd_section;
2204 }
2205
2206 static const struct bfd_elf_special_section special_sections_b[] =
2207 {
2208   { ".bss",            4, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2209   { NULL,              0,  0, 0,            0 }
2210 };
2211
2212 static const struct bfd_elf_special_section special_sections_c[] =
2213 {
2214   { ".comment",        8,  0, SHT_PROGBITS, 0 },
2215   { NULL,              0,  0, 0,            0 }
2216 };
2217
2218 static const struct bfd_elf_special_section special_sections_d[] =
2219 {
2220   { ".data",           5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2221   { ".data1",          6,  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2222   { ".debug",          6,  0, SHT_PROGBITS, 0 },
2223   { ".debug_line",    11,  0, SHT_PROGBITS, 0 },
2224   { ".debug_info",    11,  0, SHT_PROGBITS, 0 },
2225   { ".debug_abbrev",  13,  0, SHT_PROGBITS, 0 },
2226   { ".debug_aranges", 14,  0, SHT_PROGBITS, 0 },
2227   { ".dynamic",        8,  0, SHT_DYNAMIC,  SHF_ALLOC },
2228   { ".dynstr",         7,  0, SHT_STRTAB,   SHF_ALLOC },
2229   { ".dynsym",         7,  0, SHT_DYNSYM,   SHF_ALLOC },
2230   { NULL,              0,  0, 0,            0 }
2231 };
2232
2233 static const struct bfd_elf_special_section special_sections_f[] =
2234 {
2235   { ".fini",           5,  0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2236   { ".fini_array",    11,  0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2237   { NULL,              0,  0, 0,            0 }
2238 };
2239
2240 static const struct bfd_elf_special_section special_sections_g[] =
2241 {
2242   { ".gnu.linkonce.b",15, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2243   { ".got",            4,  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2244   { ".gnu.version",   12,  0, SHT_GNU_versym, 0 },
2245   { ".gnu.version_d", 14,  0, SHT_GNU_verdef, 0 },
2246   { ".gnu.version_r", 14,  0, SHT_GNU_verneed, 0 },
2247   { ".gnu.liblist",   12,  0, SHT_GNU_LIBLIST, SHF_ALLOC },
2248   { ".gnu.conflict",  13,  0, SHT_RELA,     SHF_ALLOC },
2249   { NULL,              0,  0, 0,            0 }
2250 };
2251
2252 static const struct bfd_elf_special_section special_sections_h[] =
2253 {
2254   { ".hash",           5,  0, SHT_HASH,     SHF_ALLOC },
2255   { NULL,              0,  0, 0,            0 }
2256 };
2257
2258 static const struct bfd_elf_special_section special_sections_i[] =
2259 {
2260   { ".init",           5,  0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2261   { ".init_array",    11,  0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2262   { ".interp",         7,  0, SHT_PROGBITS, 0 },
2263   { NULL,              0,  0, 0,            0 }
2264 };
2265
2266 static const struct bfd_elf_special_section special_sections_l[] =
2267 {
2268   { ".line",           5,  0, SHT_PROGBITS, 0 },
2269   { NULL,              0,  0, 0,            0 }
2270 };
2271
2272 static const struct bfd_elf_special_section special_sections_n[] =
2273 {
2274   { ".note.GNU-stack",15,  0, SHT_PROGBITS, 0 },
2275   { ".note",           5, -1, SHT_NOTE,     0 },
2276   { NULL,              0,  0, 0,            0 }
2277 };
2278
2279 static const struct bfd_elf_special_section special_sections_p[] =
2280 {
2281   { ".preinit_array", 14,  0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2282   { ".plt",            4,  0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2283   { NULL,              0,  0, 0,            0 }
2284 };
2285
2286 static const struct bfd_elf_special_section special_sections_r[] =
2287 {
2288   { ".rodata",         7, -2, SHT_PROGBITS, SHF_ALLOC },
2289   { ".rodata1",        8,  0, SHT_PROGBITS, SHF_ALLOC },
2290   { ".rela",           5, -1, SHT_RELA,     0 },
2291   { ".rel",            4, -1, SHT_REL,      0 },
2292   { NULL,              0,  0, 0,            0 }
2293 };
2294
2295 static const struct bfd_elf_special_section special_sections_s[] =
2296 {
2297   { ".shstrtab",       9,  0, SHT_STRTAB,   0 },
2298   { ".strtab",         7,  0, SHT_STRTAB,   0 },
2299   { ".symtab",         7,  0, SHT_SYMTAB,   0 },
2300   { ".stabstr",        5,  3, SHT_STRTAB,   0 },
2301   { NULL,              0,  0, 0,            0 }
2302 };
2303
2304 static const struct bfd_elf_special_section special_sections_t[] =
2305 {
2306   { ".text",           5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2307   { ".tbss",           5, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_TLS },
2308   { ".tdata",          6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2309   { NULL,              0,  0, 0,            0 }
2310 };
2311
2312 static const struct bfd_elf_special_section *special_sections[] =
2313 {
2314   special_sections_b,           /* 'b' */
2315   special_sections_c,           /* 'b' */
2316   special_sections_d,           /* 'd' */
2317   NULL,                         /* 'e' */
2318   special_sections_f,           /* 'f' */
2319   special_sections_g,           /* 'g' */
2320   special_sections_h,           /* 'h' */
2321   special_sections_i,           /* 'i' */
2322   NULL,                         /* 'j' */
2323   NULL,                         /* 'k' */
2324   special_sections_l,           /* 'l' */
2325   NULL,                         /* 'm' */
2326   special_sections_n,           /* 'n' */
2327   NULL,                         /* 'o' */
2328   special_sections_p,           /* 'p' */
2329   NULL,                         /* 'q' */
2330   special_sections_r,           /* 'r' */
2331   special_sections_s,           /* 's' */
2332   special_sections_t,           /* 't' */
2333 };
2334
2335 const struct bfd_elf_special_section *
2336 _bfd_elf_get_special_section (const char *name,
2337                               const struct bfd_elf_special_section *spec,
2338                               unsigned int rela)
2339 {
2340   int i;
2341   int len;
2342
2343   len = strlen (name);
2344
2345   for (i = 0; spec[i].prefix != NULL; i++)
2346     {
2347       int suffix_len;
2348       int prefix_len = spec[i].prefix_length;
2349
2350       if (len < prefix_len)
2351         continue;
2352       if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2353         continue;
2354
2355       suffix_len = spec[i].suffix_length;
2356       if (suffix_len <= 0)
2357         {
2358           if (name[prefix_len] != 0)
2359             {
2360               if (suffix_len == 0)
2361                 continue;
2362               if (name[prefix_len] != '.'
2363                   && (suffix_len == -2
2364                       || (rela && spec[i].type == SHT_REL)))
2365                 continue;
2366             }
2367         }
2368       else
2369         {
2370           if (len < prefix_len + suffix_len)
2371             continue;
2372           if (memcmp (name + len - suffix_len,
2373                       spec[i].prefix + prefix_len,
2374                       suffix_len) != 0)
2375             continue;
2376         }
2377       return &spec[i];
2378     }
2379
2380   return NULL;
2381 }
2382
2383 const struct bfd_elf_special_section *
2384 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2385 {
2386   int i;
2387   const struct bfd_elf_special_section *spec;
2388   const struct elf_backend_data *bed;
2389
2390   /* See if this is one of the special sections.  */
2391   if (sec->name == NULL)
2392     return NULL;
2393
2394   bed = get_elf_backend_data (abfd);
2395   spec = bed->special_sections;
2396   if (spec)
2397     {
2398       spec = _bfd_elf_get_special_section (sec->name,
2399                                            bed->special_sections,
2400                                            sec->use_rela_p);
2401       if (spec != NULL)
2402         return spec;
2403     }
2404
2405   if (sec->name[0] != '.')
2406     return NULL;
2407
2408   i = sec->name[1] - 'b';
2409   if (i < 0 || i > 't' - 'b')
2410     return NULL;
2411
2412   spec = special_sections[i];
2413
2414   if (spec == NULL)
2415     return NULL;
2416
2417   return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2418 }
2419
2420 bfd_boolean
2421 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2422 {
2423   struct bfd_elf_section_data *sdata;
2424   const struct elf_backend_data *bed;
2425   const struct bfd_elf_special_section *ssect;
2426
2427   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2428   if (sdata == NULL)
2429     {
2430       sdata = bfd_zalloc (abfd, sizeof (*sdata));
2431       if (sdata == NULL)
2432         return FALSE;
2433       sec->used_by_bfd = sdata;
2434     }
2435
2436   /* Indicate whether or not this section should use RELA relocations.  */
2437   bed = get_elf_backend_data (abfd);
2438   sec->use_rela_p = bed->default_use_rela_p;
2439
2440   /* When we read a file, we don't need section type and flags unless
2441      it is a linker created section.  They will be overridden in
2442      _bfd_elf_make_section_from_shdr anyway.  */
2443   if (abfd->direction != read_direction
2444       || (sec->flags & SEC_LINKER_CREATED) != 0)
2445     {
2446       ssect = (*bed->get_sec_type_attr) (abfd, sec);
2447       if (ssect != NULL)
2448         {
2449           elf_section_type (sec) = ssect->type;
2450           elf_section_flags (sec) = ssect->attr;
2451         }
2452     }
2453
2454   return TRUE;
2455 }
2456
2457 /* Create a new bfd section from an ELF program header.
2458
2459    Since program segments have no names, we generate a synthetic name
2460    of the form segment<NUM>, where NUM is generally the index in the
2461    program header table.  For segments that are split (see below) we
2462    generate the names segment<NUM>a and segment<NUM>b.
2463
2464    Note that some program segments may have a file size that is different than
2465    (less than) the memory size.  All this means is that at execution the
2466    system must allocate the amount of memory specified by the memory size,
2467    but only initialize it with the first "file size" bytes read from the
2468    file.  This would occur for example, with program segments consisting
2469    of combined data+bss.
2470
2471    To handle the above situation, this routine generates TWO bfd sections
2472    for the single program segment.  The first has the length specified by
2473    the file size of the segment, and the second has the length specified
2474    by the difference between the two sizes.  In effect, the segment is split
2475    into it's initialized and uninitialized parts.
2476
2477  */
2478
2479 bfd_boolean
2480 _bfd_elf_make_section_from_phdr (bfd *abfd,
2481                                  Elf_Internal_Phdr *hdr,
2482                                  int index,
2483                                  const char *typename)
2484 {
2485   asection *newsect;
2486   char *name;
2487   char namebuf[64];
2488   size_t len;
2489   int split;
2490
2491   split = ((hdr->p_memsz > 0)
2492             && (hdr->p_filesz > 0)
2493             && (hdr->p_memsz > hdr->p_filesz));
2494   sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2495   len = strlen (namebuf) + 1;
2496   name = bfd_alloc (abfd, len);
2497   if (!name)
2498     return FALSE;
2499   memcpy (name, namebuf, len);
2500   newsect = bfd_make_section (abfd, name);
2501   if (newsect == NULL)
2502     return FALSE;
2503   newsect->vma = hdr->p_vaddr;
2504   newsect->lma = hdr->p_paddr;
2505   newsect->size = hdr->p_filesz;
2506   newsect->filepos = hdr->p_offset;
2507   newsect->flags |= SEC_HAS_CONTENTS;
2508   newsect->alignment_power = bfd_log2 (hdr->p_align);
2509   if (hdr->p_type == PT_LOAD)
2510     {
2511       newsect->flags |= SEC_ALLOC;
2512       newsect->flags |= SEC_LOAD;
2513       if (hdr->p_flags & PF_X)
2514         {
2515           /* FIXME: all we known is that it has execute PERMISSION,
2516              may be data.  */
2517           newsect->flags |= SEC_CODE;
2518         }
2519     }
2520   if (!(hdr->p_flags & PF_W))
2521     {
2522       newsect->flags |= SEC_READONLY;
2523     }
2524
2525   if (split)
2526     {
2527       sprintf (namebuf, "%s%db", typename, index);
2528       len = strlen (namebuf) + 1;
2529       name = bfd_alloc (abfd, len);
2530       if (!name)
2531         return FALSE;
2532       memcpy (name, namebuf, len);
2533       newsect = bfd_make_section (abfd, name);
2534       if (newsect == NULL)
2535         return FALSE;
2536       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2537       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2538       newsect->size = hdr->p_memsz - hdr->p_filesz;
2539       if (hdr->p_type == PT_LOAD)
2540         {
2541           newsect->flags |= SEC_ALLOC;
2542           if (hdr->p_flags & PF_X)
2543             newsect->flags |= SEC_CODE;
2544         }
2545       if (!(hdr->p_flags & PF_W))
2546         newsect->flags |= SEC_READONLY;
2547     }
2548
2549   return TRUE;
2550 }
2551
2552 bfd_boolean
2553 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2554 {
2555   const struct elf_backend_data *bed;
2556
2557   switch (hdr->p_type)
2558     {
2559     case PT_NULL:
2560       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2561
2562     case PT_LOAD:
2563       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2564
2565     case PT_DYNAMIC:
2566       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2567
2568     case PT_INTERP:
2569       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2570
2571     case PT_NOTE:
2572       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2573         return FALSE;
2574       if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2575         return FALSE;
2576       return TRUE;
2577
2578     case PT_SHLIB:
2579       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2580
2581     case PT_PHDR:
2582       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2583
2584     case PT_GNU_EH_FRAME:
2585       return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2586                                               "eh_frame_hdr");
2587
2588     case PT_GNU_STACK:
2589       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2590
2591     case PT_GNU_RELRO:
2592       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2593
2594     default:
2595       /* Check for any processor-specific program segment types.  */
2596       bed = get_elf_backend_data (abfd);
2597       return bed->elf_backend_section_from_phdr (abfd, hdr, index, "proc");
2598     }
2599 }
2600
2601 /* Initialize REL_HDR, the section-header for new section, containing
2602    relocations against ASECT.  If USE_RELA_P is TRUE, we use RELA
2603    relocations; otherwise, we use REL relocations.  */
2604
2605 bfd_boolean
2606 _bfd_elf_init_reloc_shdr (bfd *abfd,
2607                           Elf_Internal_Shdr *rel_hdr,
2608                           asection *asect,
2609                           bfd_boolean use_rela_p)
2610 {
2611   char *name;
2612   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2613   bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2614
2615   name = bfd_alloc (abfd, amt);
2616   if (name == NULL)
2617     return FALSE;
2618   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2619   rel_hdr->sh_name =
2620     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2621                                         FALSE);
2622   if (rel_hdr->sh_name == (unsigned int) -1)
2623     return FALSE;
2624   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2625   rel_hdr->sh_entsize = (use_rela_p
2626                          ? bed->s->sizeof_rela
2627                          : bed->s->sizeof_rel);
2628   rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2629   rel_hdr->sh_flags = 0;
2630   rel_hdr->sh_addr = 0;
2631   rel_hdr->sh_size = 0;
2632   rel_hdr->sh_offset = 0;
2633
2634   return TRUE;
2635 }
2636
2637 /* Set up an ELF internal section header for a section.  */
2638
2639 static void
2640 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2641 {
2642   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2643   bfd_boolean *failedptr = failedptrarg;
2644   Elf_Internal_Shdr *this_hdr;
2645
2646   if (*failedptr)
2647     {
2648       /* We already failed; just get out of the bfd_map_over_sections
2649          loop.  */
2650       return;
2651     }
2652
2653   this_hdr = &elf_section_data (asect)->this_hdr;
2654
2655   this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2656                                                           asect->name, FALSE);
2657   if (this_hdr->sh_name == (unsigned int) -1)
2658     {
2659       *failedptr = TRUE;
2660       return;
2661     }
2662
2663   /* Don't clear sh_flags. Assembler may set additional bits.  */
2664
2665   if ((asect->flags & SEC_ALLOC) != 0
2666       || asect->user_set_vma)
2667     this_hdr->sh_addr = asect->vma;
2668   else
2669     this_hdr->sh_addr = 0;
2670
2671   this_hdr->sh_offset = 0;
2672   this_hdr->sh_size = asect->size;
2673   this_hdr->sh_link = 0;
2674   this_hdr->sh_addralign = 1 << asect->alignment_power;
2675   /* The sh_entsize and sh_info fields may have been set already by
2676      copy_private_section_data.  */
2677
2678   this_hdr->bfd_section = asect;
2679   this_hdr->contents = NULL;
2680
2681   /* If the section type is unspecified, we set it based on
2682      asect->flags.  */
2683   if (this_hdr->sh_type == SHT_NULL)
2684     {
2685       if ((asect->flags & SEC_GROUP) != 0)
2686         this_hdr->sh_type = SHT_GROUP;
2687       else if ((asect->flags & SEC_ALLOC) != 0
2688           && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2689               || (asect->flags & SEC_NEVER_LOAD) != 0))
2690         this_hdr->sh_type = SHT_NOBITS;
2691       else
2692         this_hdr->sh_type = SHT_PROGBITS;
2693     }
2694
2695   switch (this_hdr->sh_type)
2696     {
2697     default:
2698       break;
2699
2700     case SHT_STRTAB:
2701     case SHT_INIT_ARRAY:
2702     case SHT_FINI_ARRAY:
2703     case SHT_PREINIT_ARRAY:
2704     case SHT_NOTE:
2705     case SHT_NOBITS:
2706     case SHT_PROGBITS:
2707       break;
2708
2709     case SHT_HASH:
2710       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2711       break;
2712
2713     case SHT_DYNSYM:
2714       this_hdr->sh_entsize = bed->s->sizeof_sym;
2715       break;
2716
2717     case SHT_DYNAMIC:
2718       this_hdr->sh_entsize = bed->s->sizeof_dyn;
2719       break;
2720
2721     case SHT_RELA:
2722       if (get_elf_backend_data (abfd)->may_use_rela_p)
2723         this_hdr->sh_entsize = bed->s->sizeof_rela;
2724       break;
2725
2726      case SHT_REL:
2727       if (get_elf_backend_data (abfd)->may_use_rel_p)
2728         this_hdr->sh_entsize = bed->s->sizeof_rel;
2729       break;
2730
2731      case SHT_GNU_versym:
2732       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2733       break;
2734
2735      case SHT_GNU_verdef:
2736       this_hdr->sh_entsize = 0;
2737       /* objcopy or strip will copy over sh_info, but may not set
2738          cverdefs.  The linker will set cverdefs, but sh_info will be
2739          zero.  */
2740       if (this_hdr->sh_info == 0)
2741         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2742       else
2743         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2744                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2745       break;
2746
2747     case SHT_GNU_verneed:
2748       this_hdr->sh_entsize = 0;
2749       /* objcopy or strip will copy over sh_info, but may not set
2750          cverrefs.  The linker will set cverrefs, but sh_info will be
2751          zero.  */
2752       if (this_hdr->sh_info == 0)
2753         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2754       else
2755         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2756                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2757       break;
2758
2759     case SHT_GROUP:
2760       this_hdr->sh_entsize = 4;
2761       break;
2762     }
2763
2764   if ((asect->flags & SEC_ALLOC) != 0)
2765     this_hdr->sh_flags |= SHF_ALLOC;
2766   if ((asect->flags & SEC_READONLY) == 0)
2767     this_hdr->sh_flags |= SHF_WRITE;
2768   if ((asect->flags & SEC_CODE) != 0)
2769     this_hdr->sh_flags |= SHF_EXECINSTR;
2770   if ((asect->flags & SEC_MERGE) != 0)
2771     {
2772       this_hdr->sh_flags |= SHF_MERGE;
2773       this_hdr->sh_entsize = asect->entsize;
2774       if ((asect->flags & SEC_STRINGS) != 0)
2775         this_hdr->sh_flags |= SHF_STRINGS;
2776     }
2777   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2778     this_hdr->sh_flags |= SHF_GROUP;
2779   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2780     {
2781       this_hdr->sh_flags |= SHF_TLS;
2782       if (asect->size == 0
2783           && (asect->flags & SEC_HAS_CONTENTS) == 0)
2784         {
2785           struct bfd_link_order *o = asect->map_tail.link_order;
2786
2787           this_hdr->sh_size = 0;
2788           if (o != NULL)
2789             {
2790               this_hdr->sh_size = o->offset + o->size;
2791               if (this_hdr->sh_size != 0)
2792                 this_hdr->sh_type = SHT_NOBITS;
2793             }
2794         }
2795     }
2796
2797   /* Check for processor-specific section types.  */
2798   if (bed->elf_backend_fake_sections
2799       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2800     *failedptr = TRUE;
2801
2802   /* If the section has relocs, set up a section header for the
2803      SHT_REL[A] section.  If two relocation sections are required for
2804      this section, it is up to the processor-specific back-end to
2805      create the other.  */
2806   if ((asect->flags & SEC_RELOC) != 0
2807       && !_bfd_elf_init_reloc_shdr (abfd,
2808                                     &elf_section_data (asect)->rel_hdr,
2809                                     asect,
2810                                     asect->use_rela_p))
2811     *failedptr = TRUE;
2812 }
2813
2814 /* Fill in the contents of a SHT_GROUP section.  */
2815
2816 void
2817 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2818 {
2819   bfd_boolean *failedptr = failedptrarg;
2820   unsigned long symindx;
2821   asection *elt, *first;
2822   unsigned char *loc;
2823   bfd_boolean gas;
2824
2825   /* Ignore linker created group section.  See elfNN_ia64_object_p in
2826      elfxx-ia64.c.  */
2827   if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2828       || *failedptr)
2829     return;
2830
2831   symindx = 0;
2832   if (elf_group_id (sec) != NULL)
2833     symindx = elf_group_id (sec)->udata.i;
2834
2835   if (symindx == 0)
2836     {
2837       /* If called from the assembler, swap_out_syms will have set up
2838          elf_section_syms;  If called for "ld -r", use target_index.  */
2839       if (elf_section_syms (abfd) != NULL)
2840         symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2841       else
2842         symindx = sec->target_index;
2843     }
2844   elf_section_data (sec)->this_hdr.sh_info = symindx;
2845
2846   /* The contents won't be allocated for "ld -r" or objcopy.  */
2847   gas = TRUE;
2848   if (sec->contents == NULL)
2849     {
2850       gas = FALSE;
2851       sec->contents = bfd_alloc (abfd, sec->size);
2852
2853       /* Arrange for the section to be written out.  */
2854       elf_section_data (sec)->this_hdr.contents = sec->contents;
2855       if (sec->contents == NULL)
2856         {
2857           *failedptr = TRUE;
2858           return;
2859         }
2860     }
2861
2862   loc = sec->contents + sec->size;
2863
2864   /* Get the pointer to the first section in the group that gas
2865      squirreled away here.  objcopy arranges for this to be set to the
2866      start of the input section group.  */
2867   first = elt = elf_next_in_group (sec);
2868
2869   /* First element is a flag word.  Rest of section is elf section
2870      indices for all the sections of the group.  Write them backwards
2871      just to keep the group in the same order as given in .section
2872      directives, not that it matters.  */
2873   while (elt != NULL)
2874     {
2875       asection *s;
2876       unsigned int idx;
2877
2878       loc -= 4;
2879       s = elt;
2880       if (!gas)
2881         s = s->output_section;
2882       idx = 0;
2883       if (s != NULL)
2884         idx = elf_section_data (s)->this_idx;
2885       H_PUT_32 (abfd, idx, loc);
2886       elt = elf_next_in_group (elt);
2887       if (elt == first)
2888         break;
2889     }
2890
2891   if ((loc -= 4) != sec->contents)
2892     abort ();
2893
2894   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2895 }
2896
2897 /* Assign all ELF section numbers.  The dummy first section is handled here
2898    too.  The link/info pointers for the standard section types are filled
2899    in here too, while we're at it.  */
2900
2901 static bfd_boolean
2902 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2903 {
2904   struct elf_obj_tdata *t = elf_tdata (abfd);
2905   asection *sec;
2906   unsigned int section_number, secn;
2907   Elf_Internal_Shdr **i_shdrp;
2908   struct bfd_elf_section_data *d;
2909
2910   section_number = 1;
2911
2912   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2913
2914   /* SHT_GROUP sections are in relocatable files only.  */
2915   if (link_info == NULL || link_info->relocatable)
2916     {
2917       /* Put SHT_GROUP sections first.  */
2918       for (sec = abfd->sections; sec != NULL; sec = sec->next)
2919         {
2920           d = elf_section_data (sec);
2921
2922           if (d->this_hdr.sh_type == SHT_GROUP)
2923             {
2924               if (sec->flags & SEC_LINKER_CREATED)
2925                 {
2926                   /* Remove the linker created SHT_GROUP sections.  */
2927                   bfd_section_list_remove (abfd, sec);
2928                   abfd->section_count--;
2929                 }
2930               else
2931                 {
2932                   if (section_number == SHN_LORESERVE)
2933                     section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2934                   d->this_idx = section_number++;
2935                 }
2936             }
2937         }
2938     }
2939
2940   for (sec = abfd->sections; sec; sec = sec->next)
2941     {
2942       d = elf_section_data (sec);
2943
2944       if (d->this_hdr.sh_type != SHT_GROUP)
2945         {
2946           if (section_number == SHN_LORESERVE)
2947             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2948           d->this_idx = section_number++;
2949         }
2950       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2951       if ((sec->flags & SEC_RELOC) == 0)
2952         d->rel_idx = 0;
2953       else
2954         {
2955           if (section_number == SHN_LORESERVE)
2956             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2957           d->rel_idx = section_number++;
2958           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2959         }
2960
2961       if (d->rel_hdr2)
2962         {
2963           if (section_number == SHN_LORESERVE)
2964             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2965           d->rel_idx2 = section_number++;
2966           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2967         }
2968       else
2969         d->rel_idx2 = 0;
2970     }
2971
2972   if (section_number == SHN_LORESERVE)
2973     section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2974   t->shstrtab_section = section_number++;
2975   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2976   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2977
2978   if (bfd_get_symcount (abfd) > 0)
2979     {
2980       if (section_number == SHN_LORESERVE)
2981         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2982       t->symtab_section = section_number++;
2983       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2984       if (section_number > SHN_LORESERVE - 2)
2985         {
2986           if (section_number == SHN_LORESERVE)
2987             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2988           t->symtab_shndx_section = section_number++;
2989           t->symtab_shndx_hdr.sh_name
2990             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2991                                                   ".symtab_shndx", FALSE);
2992           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2993             return FALSE;
2994         }
2995       if (section_number == SHN_LORESERVE)
2996         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2997       t->strtab_section = section_number++;
2998       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2999     }
3000
3001   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
3002   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3003
3004   elf_numsections (abfd) = section_number;
3005   elf_elfheader (abfd)->e_shnum = section_number;
3006   if (section_number > SHN_LORESERVE)
3007     elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
3008
3009   /* Set up the list of section header pointers, in agreement with the
3010      indices.  */
3011   i_shdrp = bfd_zalloc2 (abfd, section_number, sizeof (Elf_Internal_Shdr *));
3012   if (i_shdrp == NULL)
3013     return FALSE;
3014
3015   i_shdrp[0] = bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
3016   if (i_shdrp[0] == NULL)
3017     {
3018       bfd_release (abfd, i_shdrp);
3019       return FALSE;
3020     }
3021
3022   elf_elfsections (abfd) = i_shdrp;
3023
3024   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3025   if (bfd_get_symcount (abfd) > 0)
3026     {
3027       i_shdrp[t->symtab_section] = &t->symtab_hdr;
3028       if (elf_numsections (abfd) > SHN_LORESERVE)
3029         {
3030           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3031           t->symtab_shndx_hdr.sh_link = t->symtab_section;
3032         }
3033       i_shdrp[t->strtab_section] = &t->strtab_hdr;
3034       t->symtab_hdr.sh_link = t->strtab_section;
3035     }
3036
3037   for (sec = abfd->sections; sec; sec = sec->next)
3038     {
3039       struct bfd_elf_section_data *d = elf_section_data (sec);
3040       asection *s;
3041       const char *name;
3042
3043       i_shdrp[d->this_idx] = &d->this_hdr;
3044       if (d->rel_idx != 0)
3045         i_shdrp[d->rel_idx] = &d->rel_hdr;
3046       if (d->rel_idx2 != 0)
3047         i_shdrp[d->rel_idx2] = d->rel_hdr2;
3048
3049       /* Fill in the sh_link and sh_info fields while we're at it.  */
3050
3051       /* sh_link of a reloc section is the section index of the symbol
3052          table.  sh_info is the section index of the section to which
3053          the relocation entries apply.  */
3054       if (d->rel_idx != 0)
3055         {
3056           d->rel_hdr.sh_link = t->symtab_section;
3057           d->rel_hdr.sh_info = d->this_idx;
3058         }
3059       if (d->rel_idx2 != 0)
3060         {
3061           d->rel_hdr2->sh_link = t->symtab_section;
3062           d->rel_hdr2->sh_info = d->this_idx;
3063         }
3064
3065       /* We need to set up sh_link for SHF_LINK_ORDER.  */
3066       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3067         {
3068           s = elf_linked_to_section (sec);
3069           if (s)
3070             {
3071               /* elf_linked_to_section points to the input section.  */
3072               if (link_info != NULL)
3073                 {
3074                   /* Check discarded linkonce section.  */
3075                   if (elf_discarded_section (s))
3076                     {
3077                       asection *kept;
3078                       (*_bfd_error_handler)
3079                         (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3080                          abfd, d->this_hdr.bfd_section,
3081                          s, s->owner);
3082                       /* Point to the kept section if it has the same
3083                          size as the discarded one.  */
3084                       kept = _bfd_elf_check_kept_section (s);
3085                       if (kept == NULL)
3086                         {
3087                           bfd_set_error (bfd_error_bad_value);
3088                           return FALSE;
3089                         }
3090                       s = kept;
3091                     }
3092
3093                   s = s->output_section;
3094                   BFD_ASSERT (s != NULL);
3095                 }
3096               else
3097                 {
3098                   /* Handle objcopy. */
3099                   if (s->output_section == NULL)
3100                     {
3101                       (*_bfd_error_handler)
3102                         (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3103                          abfd, d->this_hdr.bfd_section, s, s->owner);
3104                       bfd_set_error (bfd_error_bad_value);
3105                       return FALSE;
3106                     }
3107                   s = s->output_section;
3108                 }
3109               d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3110             }
3111           else
3112             {
3113               /* PR 290:
3114                  The Intel C compiler generates SHT_IA_64_UNWIND with
3115                  SHF_LINK_ORDER.  But it doesn't set the sh_link or
3116                  sh_info fields.  Hence we could get the situation
3117                  where s is NULL.  */
3118               const struct elf_backend_data *bed
3119                 = get_elf_backend_data (abfd);
3120               if (bed->link_order_error_handler)
3121                 bed->link_order_error_handler
3122                   (_("%B: warning: sh_link not set for section `%A'"),
3123                    abfd, sec);
3124             }
3125         }
3126
3127       switch (d->this_hdr.sh_type)
3128         {
3129         case SHT_REL:
3130         case SHT_RELA:
3131           /* A reloc section which we are treating as a normal BFD
3132              section.  sh_link is the section index of the symbol
3133              table.  sh_info is the section index of the section to
3134              which the relocation entries apply.  We assume that an
3135              allocated reloc section uses the dynamic symbol table.
3136              FIXME: How can we be sure?  */
3137           s = bfd_get_section_by_name (abfd, ".dynsym");
3138           if (s != NULL)
3139             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3140
3141           /* We look up the section the relocs apply to by name.  */
3142           name = sec->name;
3143           if (d->this_hdr.sh_type == SHT_REL)
3144             name += 4;
3145           else
3146             name += 5;
3147           s = bfd_get_section_by_name (abfd, name);
3148           if (s != NULL)
3149             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3150           break;
3151
3152         case SHT_STRTAB:
3153           /* We assume that a section named .stab*str is a stabs
3154              string section.  We look for a section with the same name
3155              but without the trailing ``str'', and set its sh_link
3156              field to point to this section.  */
3157           if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
3158               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3159             {
3160               size_t len;
3161               char *alc;
3162
3163               len = strlen (sec->name);
3164               alc = bfd_malloc (len - 2);
3165               if (alc == NULL)
3166                 return FALSE;
3167               memcpy (alc, sec->name, len - 3);
3168               alc[len - 3] = '\0';
3169               s = bfd_get_section_by_name (abfd, alc);
3170               free (alc);
3171               if (s != NULL)
3172                 {
3173                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3174
3175                   /* This is a .stab section.  */
3176                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3177                     elf_section_data (s)->this_hdr.sh_entsize
3178                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3179                 }
3180             }
3181           break;
3182
3183         case SHT_DYNAMIC:
3184         case SHT_DYNSYM:
3185         case SHT_GNU_verneed:
3186         case SHT_GNU_verdef:
3187           /* sh_link is the section header index of the string table
3188              used for the dynamic entries, or the symbol table, or the
3189              version strings.  */
3190           s = bfd_get_section_by_name (abfd, ".dynstr");
3191           if (s != NULL)
3192             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3193           break;
3194
3195         case SHT_GNU_LIBLIST:
3196           /* sh_link is the section header index of the prelink library
3197              list
3198              used for the dynamic entries, or the symbol table, or the
3199              version strings.  */
3200           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3201                                              ? ".dynstr" : ".gnu.libstr");
3202           if (s != NULL)
3203             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3204           break;
3205
3206         case SHT_HASH:
3207         case SHT_GNU_versym:
3208           /* sh_link is the section header index of the symbol table
3209              this hash table or version table is for.  */
3210           s = bfd_get_section_by_name (abfd, ".dynsym");
3211           if (s != NULL)
3212             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3213           break;
3214
3215         case SHT_GROUP:
3216           d->this_hdr.sh_link = t->symtab_section;
3217         }
3218     }
3219
3220   for (secn = 1; secn < section_number; ++secn)
3221     if (i_shdrp[secn] == NULL)
3222       i_shdrp[secn] = i_shdrp[0];
3223     else
3224       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3225                                                        i_shdrp[secn]->sh_name);
3226   return TRUE;
3227 }
3228
3229 /* Map symbol from it's internal number to the external number, moving
3230    all local symbols to be at the head of the list.  */
3231
3232 static int
3233 sym_is_global (bfd *abfd, asymbol *sym)
3234 {
3235   /* If the backend has a special mapping, use it.  */
3236   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3237   if (bed->elf_backend_sym_is_global)
3238     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3239
3240   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3241           || bfd_is_und_section (bfd_get_section (sym))
3242           || bfd_is_com_section (bfd_get_section (sym)));
3243 }
3244
3245 static bfd_boolean
3246 elf_map_symbols (bfd *abfd)
3247 {
3248   unsigned int symcount = bfd_get_symcount (abfd);
3249   asymbol **syms = bfd_get_outsymbols (abfd);
3250   asymbol **sect_syms;
3251   unsigned int num_locals = 0;
3252   unsigned int num_globals = 0;
3253   unsigned int num_locals2 = 0;
3254   unsigned int num_globals2 = 0;
3255   int max_index = 0;
3256   unsigned int idx;
3257   asection *asect;
3258   asymbol **new_syms;
3259
3260 #ifdef DEBUG
3261   fprintf (stderr, "elf_map_symbols\n");
3262   fflush (stderr);
3263 #endif
3264
3265   for (asect = abfd->sections; asect; asect = asect->next)
3266     {
3267       if (max_index < asect->index)
3268         max_index = asect->index;
3269     }
3270
3271   max_index++;
3272   sect_syms = bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3273   if (sect_syms == NULL)
3274     return FALSE;
3275   elf_section_syms (abfd) = sect_syms;
3276   elf_num_section_syms (abfd) = max_index;
3277
3278   /* Init sect_syms entries for any section symbols we have already
3279      decided to output.  */
3280   for (idx = 0; idx < symcount; idx++)
3281     {
3282       asymbol *sym = syms[idx];
3283
3284       if ((sym->flags & BSF_SECTION_SYM) != 0
3285           && sym->value == 0)
3286         {
3287           asection *sec;
3288
3289           sec = sym->section;
3290
3291           if (sec->owner != NULL)
3292             {
3293               if (sec->owner != abfd)
3294                 {
3295                   if (sec->output_offset != 0)
3296                     continue;
3297
3298                   sec = sec->output_section;
3299
3300                   /* Empty sections in the input files may have had a
3301                      section symbol created for them.  (See the comment
3302                      near the end of _bfd_generic_link_output_symbols in
3303                      linker.c).  If the linker script discards such
3304                      sections then we will reach this point.  Since we know
3305                      that we cannot avoid this case, we detect it and skip
3306                      the abort and the assignment to the sect_syms array.
3307                      To reproduce this particular case try running the
3308                      linker testsuite test ld-scripts/weak.exp for an ELF
3309                      port that uses the generic linker.  */
3310                   if (sec->owner == NULL)
3311                     continue;
3312
3313                   BFD_ASSERT (sec->owner == abfd);
3314                 }
3315               sect_syms[sec->index] = syms[idx];
3316             }
3317         }
3318     }
3319
3320   /* Classify all of the symbols.  */
3321   for (idx = 0; idx < symcount; idx++)
3322     {
3323       if (!sym_is_global (abfd, syms[idx]))
3324         num_locals++;
3325       else
3326         num_globals++;
3327     }
3328
3329   /* We will be adding a section symbol for each BFD section.  Most normal
3330      sections will already have a section symbol in outsymbols, but
3331      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3332      at least in that case.  */
3333   for (asect = abfd->sections; asect; asect = asect->next)
3334     {
3335       if (sect_syms[asect->index] == NULL)
3336         {
3337           if (!sym_is_global (abfd, asect->symbol))
3338             num_locals++;
3339           else
3340             num_globals++;
3341         }
3342     }
3343
3344   /* Now sort the symbols so the local symbols are first.  */
3345   new_syms = bfd_alloc2 (abfd, num_locals + num_globals, sizeof (asymbol *));
3346
3347   if (new_syms == NULL)
3348     return FALSE;
3349
3350   for (idx = 0; idx < symcount; idx++)
3351     {
3352       asymbol *sym = syms[idx];
3353       unsigned int i;
3354
3355       if (!sym_is_global (abfd, sym))
3356         i = num_locals2++;
3357       else
3358         i = num_locals + num_globals2++;
3359       new_syms[i] = sym;
3360       sym->udata.i = i + 1;
3361     }
3362   for (asect = abfd->sections; asect; asect = asect->next)
3363     {
3364       if (sect_syms[asect->index] == NULL)
3365         {
3366           asymbol *sym = asect->symbol;
3367           unsigned int i;
3368
3369           sect_syms[asect->index] = sym;
3370           if (!sym_is_global (abfd, sym))
3371             i = num_locals2++;
3372           else
3373             i = num_locals + num_globals2++;
3374           new_syms[i] = sym;
3375           sym->udata.i = i + 1;
3376         }
3377     }
3378
3379   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3380
3381   elf_num_locals (abfd) = num_locals;
3382   elf_num_globals (abfd) = num_globals;
3383   return TRUE;
3384 }
3385
3386 /* Align to the maximum file alignment that could be required for any
3387    ELF data structure.  */
3388
3389 static inline file_ptr
3390 align_file_position (file_ptr off, int align)
3391 {
3392   return (off + align - 1) & ~(align - 1);
3393 }
3394
3395 /* Assign a file position to a section, optionally aligning to the
3396    required section alignment.  */
3397
3398 file_ptr
3399 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3400                                            file_ptr offset,
3401                                            bfd_boolean align)
3402 {
3403   if (align)
3404     {
3405       unsigned int al;
3406
3407       al = i_shdrp->sh_addralign;
3408       if (al > 1)
3409         offset = BFD_ALIGN (offset, al);
3410     }
3411   i_shdrp->sh_offset = offset;
3412   if (i_shdrp->bfd_section != NULL)
3413     i_shdrp->bfd_section->filepos = offset;
3414   if (i_shdrp->sh_type != SHT_NOBITS)
3415     offset += i_shdrp->sh_size;
3416   return offset;
3417 }
3418
3419 /* Compute the file positions we are going to put the sections at, and
3420    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3421    is not NULL, this is being called by the ELF backend linker.  */
3422
3423 bfd_boolean
3424 _bfd_elf_compute_section_file_positions (bfd *abfd,
3425                                          struct bfd_link_info *link_info)
3426 {
3427   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3428   bfd_boolean failed;
3429   struct bfd_strtab_hash *strtab = NULL;
3430   Elf_Internal_Shdr *shstrtab_hdr;
3431
3432   if (abfd->output_has_begun)
3433     return TRUE;
3434
3435   /* Do any elf backend specific processing first.  */
3436   if (bed->elf_backend_begin_write_processing)
3437     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3438
3439   if (! prep_headers (abfd))
3440     return FALSE;
3441
3442   /* Post process the headers if necessary.  */
3443   if (bed->elf_backend_post_process_headers)
3444     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3445
3446   failed = FALSE;
3447   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3448   if (failed)
3449     return FALSE;
3450
3451   if (!assign_section_numbers (abfd, link_info))
3452     return FALSE;
3453
3454   /* The backend linker builds symbol table information itself.  */
3455   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3456     {
3457       /* Non-zero if doing a relocatable link.  */
3458       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3459
3460       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3461         return FALSE;
3462     }
3463
3464   if (link_info == NULL)
3465     {
3466       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3467       if (failed)
3468         return FALSE;
3469     }
3470
3471   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3472   /* sh_name was set in prep_headers.  */
3473   shstrtab_hdr->sh_type = SHT_STRTAB;
3474   shstrtab_hdr->sh_flags = 0;
3475   shstrtab_hdr->sh_addr = 0;
3476   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3477   shstrtab_hdr->sh_entsize = 0;
3478   shstrtab_hdr->sh_link = 0;
3479   shstrtab_hdr->sh_info = 0;
3480   /* sh_offset is set in assign_file_positions_except_relocs.  */
3481   shstrtab_hdr->sh_addralign = 1;
3482
3483   if (!assign_file_positions_except_relocs (abfd, link_info))
3484     return FALSE;
3485
3486   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3487     {
3488       file_ptr off;
3489       Elf_Internal_Shdr *hdr;
3490
3491       off = elf_tdata (abfd)->next_file_pos;
3492
3493       hdr = &elf_tdata (abfd)->symtab_hdr;
3494       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3495
3496       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3497       if (hdr->sh_size != 0)
3498         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3499
3500       hdr = &elf_tdata (abfd)->strtab_hdr;
3501       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3502
3503       elf_tdata (abfd)->next_file_pos = off;
3504
3505       /* Now that we know where the .strtab section goes, write it
3506          out.  */
3507       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3508           || ! _bfd_stringtab_emit (abfd, strtab))
3509         return FALSE;
3510       _bfd_stringtab_free (strtab);
3511     }
3512
3513   abfd->output_has_begun = TRUE;
3514
3515   return TRUE;
3516 }
3517
3518 /* Create a mapping from a set of sections to a program segment.  */
3519
3520 static struct elf_segment_map *
3521 make_mapping (bfd *abfd,
3522               asection **sections,
3523               unsigned int from,
3524               unsigned int to,
3525               bfd_boolean phdr)
3526 {
3527   struct elf_segment_map *m;
3528   unsigned int i;
3529   asection **hdrpp;
3530   bfd_size_type amt;
3531
3532   amt = sizeof (struct elf_segment_map);
3533   amt += (to - from - 1) * sizeof (asection *);
3534   m = bfd_zalloc (abfd, amt);
3535   if (m == NULL)
3536     return NULL;
3537   m->next = NULL;
3538   m->p_type = PT_LOAD;
3539   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3540     m->sections[i - from] = *hdrpp;
3541   m->count = to - from;
3542
3543   if (from == 0 && phdr)
3544     {
3545       /* Include the headers in the first PT_LOAD segment.  */
3546       m->includes_filehdr = 1;
3547       m->includes_phdrs = 1;
3548     }
3549
3550   return m;
3551 }
3552
3553 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
3554    on failure.  */
3555
3556 struct elf_segment_map *
3557 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3558 {
3559   struct elf_segment_map *m;
3560
3561   m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3562   if (m == NULL)
3563     return NULL;
3564   m->next = NULL;
3565   m->p_type = PT_DYNAMIC;
3566   m->count = 1;
3567   m->sections[0] = dynsec;
3568
3569   return m;
3570 }
3571
3572 /* Set up a mapping from BFD sections to program segments.  */
3573
3574 static bfd_boolean
3575 map_sections_to_segments (bfd *abfd)
3576 {
3577   asection **sections = NULL;
3578   asection *s;
3579   unsigned int i;
3580   unsigned int count;
3581   struct elf_segment_map *mfirst;
3582   struct elf_segment_map **pm;
3583   struct elf_segment_map *m;
3584   asection *last_hdr;
3585   bfd_vma last_size;
3586   unsigned int phdr_index;
3587   bfd_vma maxpagesize;
3588   asection **hdrpp;
3589   bfd_boolean phdr_in_segment = TRUE;
3590   bfd_boolean writable;
3591   int tls_count = 0;
3592   asection *first_tls = NULL;
3593   asection *dynsec, *eh_frame_hdr;
3594   bfd_size_type amt;
3595
3596   if (elf_tdata (abfd)->segment_map != NULL)
3597     return TRUE;
3598
3599   if (bfd_count_sections (abfd) == 0)
3600     return TRUE;
3601
3602   /* Select the allocated sections, and sort them.  */
3603
3604   sections = bfd_malloc2 (bfd_count_sections (abfd), sizeof (asection *));
3605   if (sections == NULL)
3606     goto error_return;
3607
3608   i = 0;
3609   for (s = abfd->sections; s != NULL; s = s->next)
3610     {
3611       if ((s->flags & SEC_ALLOC) != 0)
3612         {
3613           sections[i] = s;
3614           ++i;
3615         }
3616     }
3617   BFD_ASSERT (i <= bfd_count_sections (abfd));
3618   count = i;
3619
3620   qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3621
3622   /* Build the mapping.  */
3623
3624   mfirst = NULL;
3625   pm = &mfirst;
3626
3627   /* If we have a .interp section, then create a PT_PHDR segment for
3628      the program headers and a PT_INTERP segment for the .interp
3629      section.  */
3630   s = bfd_get_section_by_name (abfd, ".interp");
3631   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3632     {
3633       amt = sizeof (struct elf_segment_map);
3634       m = bfd_zalloc (abfd, amt);
3635       if (m == NULL)
3636         goto error_return;
3637       m->next = NULL;
3638       m->p_type = PT_PHDR;
3639       /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3640       m->p_flags = PF_R | PF_X;
3641       m->p_flags_valid = 1;
3642       m->includes_phdrs = 1;
3643
3644       *pm = m;
3645       pm = &m->next;
3646
3647       amt = sizeof (struct elf_segment_map);
3648       m = bfd_zalloc (abfd, amt);
3649       if (m == NULL)
3650         goto error_return;
3651       m->next = NULL;
3652       m->p_type = PT_INTERP;
3653       m->count = 1;
3654       m->sections[0] = s;
3655
3656       *pm = m;
3657       pm = &m->next;
3658     }
3659
3660   /* Look through the sections.  We put sections in the same program
3661      segment when the start of the second section can be placed within
3662      a few bytes of the end of the first section.  */
3663   last_hdr = NULL;
3664   last_size = 0;
3665   phdr_index = 0;
3666   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3667   writable = FALSE;
3668   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3669   if (dynsec != NULL
3670       && (dynsec->flags & SEC_LOAD) == 0)
3671     dynsec = NULL;
3672
3673   /* Deal with -Ttext or something similar such that the first section
3674      is not adjacent to the program headers.  This is an
3675      approximation, since at this point we don't know exactly how many
3676      program headers we will need.  */
3677   if (count > 0)
3678     {
3679       bfd_size_type phdr_size;
3680
3681       phdr_size = elf_tdata (abfd)->program_header_size;
3682       if (phdr_size == 0)
3683         phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3684       if ((abfd->flags & D_PAGED) == 0
3685           || sections[0]->lma < phdr_size
3686           || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3687         phdr_in_segment = FALSE;
3688     }
3689
3690   for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3691     {
3692       asection *hdr;
3693       bfd_boolean new_segment;
3694
3695       hdr = *hdrpp;
3696
3697       /* See if this section and the last one will fit in the same
3698          segment.  */
3699
3700       if (last_hdr == NULL)
3701         {
3702           /* If we don't have a segment yet, then we don't need a new
3703              one (we build the last one after this loop).  */
3704           new_segment = FALSE;
3705         }
3706       else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3707         {
3708           /* If this section has a different relation between the
3709              virtual address and the load address, then we need a new
3710              segment.  */
3711           new_segment = TRUE;
3712         }
3713       else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3714                < BFD_ALIGN (hdr->lma, maxpagesize))
3715         {
3716           /* If putting this section in this segment would force us to
3717              skip a page in the segment, then we need a new segment.  */
3718           new_segment = TRUE;
3719         }
3720       else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3721                && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3722         {
3723           /* We don't want to put a loadable section after a
3724              nonloadable section in the same segment.
3725              Consider .tbss sections as loadable for this purpose.  */
3726           new_segment = TRUE;
3727         }
3728       else if ((abfd->flags & D_PAGED) == 0)
3729         {
3730           /* If the file is not demand paged, which means that we
3731              don't require the sections to be correctly aligned in the
3732              file, then there is no other reason for a new segment.  */
3733           new_segment = FALSE;
3734         }
3735       else if (! writable
3736                && (hdr->flags & SEC_READONLY) == 0
3737                && (((last_hdr->lma + last_size - 1)
3738                     & ~(maxpagesize - 1))
3739                    != (hdr->lma & ~(maxpagesize - 1))))
3740         {
3741           /* We don't want to put a writable section in a read only
3742              segment, unless they are on the same page in memory
3743              anyhow.  We already know that the last section does not
3744              bring us past the current section on the page, so the
3745              only case in which the new section is not on the same
3746              page as the previous section is when the previous section
3747              ends precisely on a page boundary.  */
3748           new_segment = TRUE;
3749         }
3750       else
3751         {
3752           /* Otherwise, we can use the same segment.  */
3753           new_segment = FALSE;
3754         }
3755
3756       if (! new_segment)
3757         {
3758           if ((hdr->flags & SEC_READONLY) == 0)
3759             writable = TRUE;
3760           last_hdr = hdr;
3761           /* .tbss sections effectively have zero size.  */
3762           if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3763             last_size = hdr->size;
3764           else
3765             last_size = 0;
3766           continue;
3767         }
3768
3769       /* We need a new program segment.  We must create a new program
3770          header holding all the sections from phdr_index until hdr.  */
3771
3772       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3773       if (m == NULL)
3774         goto error_return;
3775
3776       *pm = m;
3777       pm = &m->next;
3778
3779       if ((hdr->flags & SEC_READONLY) == 0)
3780         writable = TRUE;
3781       else
3782         writable = FALSE;
3783
3784       last_hdr = hdr;
3785       /* .tbss sections effectively have zero size.  */
3786       if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3787         last_size = hdr->size;
3788       else
3789         last_size = 0;
3790       phdr_index = i;
3791       phdr_in_segment = FALSE;
3792     }
3793
3794   /* Create a final PT_LOAD program segment.  */
3795   if (last_hdr != NULL)
3796     {
3797       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3798       if (m == NULL)
3799         goto error_return;
3800
3801       *pm = m;
3802       pm = &m->next;
3803     }
3804
3805   /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
3806   if (dynsec != NULL)
3807     {
3808       m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3809       if (m == NULL)
3810         goto error_return;
3811       *pm = m;
3812       pm = &m->next;
3813     }
3814
3815   /* For each loadable .note section, add a PT_NOTE segment.  We don't
3816      use bfd_get_section_by_name, because if we link together
3817      nonloadable .note sections and loadable .note sections, we will
3818      generate two .note sections in the output file.  FIXME: Using
3819      names for section types is bogus anyhow.  */
3820   for (s = abfd->sections; s != NULL; s = s->next)
3821     {
3822       if ((s->flags & SEC_LOAD) != 0
3823           && strncmp (s->name, ".note", 5) == 0)
3824         {
3825           amt = sizeof (struct elf_segment_map);
3826           m = bfd_zalloc (abfd, amt);
3827           if (m == NULL)
3828             goto error_return;
3829           m->next = NULL;
3830           m->p_type = PT_NOTE;
3831           m->count = 1;
3832           m->sections[0] = s;
3833
3834           *pm = m;
3835           pm = &m->next;
3836         }
3837       if (s->flags & SEC_THREAD_LOCAL)
3838         {
3839           if (! tls_count)
3840             first_tls = s;
3841           tls_count++;
3842         }
3843     }
3844
3845   /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
3846   if (tls_count > 0)
3847     {
3848       int i;
3849
3850       amt = sizeof (struct elf_segment_map);
3851       amt += (tls_count - 1) * sizeof (asection *);
3852       m = bfd_zalloc (abfd, amt);
3853       if (m == NULL)
3854         goto error_return;
3855       m->next = NULL;
3856       m->p_type = PT_TLS;
3857       m->count = tls_count;
3858       /* Mandated PF_R.  */
3859       m->p_flags = PF_R;
3860       m->p_flags_valid = 1;
3861       for (i = 0; i < tls_count; ++i)
3862         {
3863           BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3864           m->sections[i] = first_tls;
3865           first_tls = first_tls->next;
3866         }
3867
3868       *pm = m;
3869       pm = &m->next;
3870     }
3871
3872   /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3873      segment.  */
3874   eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3875   if (eh_frame_hdr != NULL
3876       && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3877     {
3878       amt = sizeof (struct elf_segment_map);
3879       m = bfd_zalloc (abfd, amt);
3880       if (m == NULL)
3881         goto error_return;
3882       m->next = NULL;
3883       m->p_type = PT_GNU_EH_FRAME;
3884       m->count = 1;
3885       m->sections[0] = eh_frame_hdr->output_section;
3886
3887       *pm = m;
3888       pm = &m->next;
3889     }
3890
3891   if (elf_tdata (abfd)->stack_flags)
3892     {
3893       amt = sizeof (struct elf_segment_map);
3894       m = bfd_zalloc (abfd, amt);
3895       if (m == NULL)
3896         goto error_return;
3897       m->next = NULL;
3898       m->p_type = PT_GNU_STACK;
3899       m->p_flags = elf_tdata (abfd)->stack_flags;
3900       m->p_flags_valid = 1;
3901
3902       *pm = m;
3903       pm = &m->next;
3904     }
3905
3906   if (elf_tdata (abfd)->relro)
3907     {
3908       amt = sizeof (struct elf_segment_map);
3909       m = bfd_zalloc (abfd, amt);
3910       if (m == NULL)
3911         goto error_return;
3912       m->next = NULL;
3913       m->p_type = PT_GNU_RELRO;
3914       m->p_flags = PF_R;
3915       m->p_flags_valid = 1;
3916
3917       *pm = m;
3918       pm = &m->next;
3919     }
3920
3921   free (sections);
3922   sections = NULL;
3923
3924   elf_tdata (abfd)->segment_map = mfirst;
3925   return TRUE;
3926
3927  error_return:
3928   if (sections != NULL)
3929     free (sections);
3930   return FALSE;
3931 }
3932
3933 /* Sort sections by address.  */
3934
3935 static int
3936 elf_sort_sections (const void *arg1, const void *arg2)
3937 {
3938   const asection *sec1 = *(const asection **) arg1;
3939   const asection *sec2 = *(const asection **) arg2;
3940   bfd_size_type size1, size2;
3941
3942   /* Sort by LMA first, since this is the address used to
3943      place the section into a segment.  */
3944   if (sec1->lma < sec2->lma)
3945     return -1;
3946   else if (sec1->lma > sec2->lma)
3947     return 1;
3948
3949   /* Then sort by VMA.  Normally the LMA and the VMA will be
3950      the same, and this will do nothing.  */
3951   if (sec1->vma < sec2->vma)
3952     return -1;
3953   else if (sec1->vma > sec2->vma)
3954     return 1;
3955
3956   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
3957
3958 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3959
3960   if (TOEND (sec1))
3961     {
3962       if (TOEND (sec2))
3963         {
3964           /* If the indicies are the same, do not return 0
3965              here, but continue to try the next comparison.  */
3966           if (sec1->target_index - sec2->target_index != 0)
3967             return sec1->target_index - sec2->target_index;
3968         }
3969       else
3970         return 1;
3971     }
3972   else if (TOEND (sec2))
3973     return -1;
3974
3975 #undef TOEND
3976
3977   /* Sort by size, to put zero sized sections
3978      before others at the same address.  */
3979
3980   size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
3981   size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
3982
3983   if (size1 < size2)
3984     return -1;
3985   if (size1 > size2)
3986     return 1;
3987
3988   return sec1->target_index - sec2->target_index;
3989 }
3990
3991 /* Ian Lance Taylor writes:
3992
3993    We shouldn't be using % with a negative signed number.  That's just
3994    not good.  We have to make sure either that the number is not
3995    negative, or that the number has an unsigned type.  When the types
3996    are all the same size they wind up as unsigned.  When file_ptr is a
3997    larger signed type, the arithmetic winds up as signed long long,
3998    which is wrong.
3999
4000    What we're trying to say here is something like ``increase OFF by
4001    the least amount that will cause it to be equal to the VMA modulo
4002    the page size.''  */
4003 /* In other words, something like:
4004
4005    vma_offset = m->sections[0]->vma % bed->maxpagesize;
4006    off_offset = off % bed->maxpagesize;
4007    if (vma_offset < off_offset)
4008      adjustment = vma_offset + bed->maxpagesize - off_offset;
4009    else
4010      adjustment = vma_offset - off_offset;
4011
4012    which can can be collapsed into the expression below.  */
4013
4014 static file_ptr
4015 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4016 {
4017   return ((vma - off) % maxpagesize);
4018 }
4019
4020 /* Assign file positions to the sections based on the mapping from
4021    sections to segments.  This function also sets up some fields in
4022    the file header, and writes out the program headers.  */
4023
4024 static bfd_boolean
4025 assign_file_positions_for_segments (bfd *abfd, struct bfd_link_info *link_info)
4026 {
4027   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4028   unsigned int count;
4029   struct elf_segment_map *m;
4030   unsigned int alloc;
4031   Elf_Internal_Phdr *phdrs;
4032   file_ptr off, voff;
4033   bfd_vma filehdr_vaddr, filehdr_paddr;
4034   bfd_vma phdrs_vaddr, phdrs_paddr;
4035   Elf_Internal_Phdr *p;
4036
4037   if (elf_tdata (abfd)->segment_map == NULL)
4038     {
4039       if (! map_sections_to_segments (abfd))
4040         return FALSE;
4041     }
4042   else
4043     {
4044       /* The placement algorithm assumes that non allocated sections are
4045          not in PT_LOAD segments.  We ensure this here by removing such
4046          sections from the segment map.  We also remove excluded
4047          sections.  */
4048       for (m = elf_tdata (abfd)->segment_map;
4049            m != NULL;
4050            m = m->next)
4051         {
4052           unsigned int new_count;
4053           unsigned int i;
4054
4055           new_count = 0;
4056           for (i = 0; i < m->count; i ++)
4057             {
4058               if ((m->sections[i]->flags & SEC_EXCLUDE) == 0
4059                   && ((m->sections[i]->flags & SEC_ALLOC) != 0
4060                       || m->p_type != PT_LOAD))
4061                 {
4062                   if (i != new_count)
4063                     m->sections[new_count] = m->sections[i];
4064
4065                   new_count ++;
4066                 }
4067             }
4068
4069           if (new_count != m->count)
4070             m->count = new_count;
4071         }
4072     }
4073
4074   if (bed->elf_backend_modify_segment_map)
4075     {
4076       if (! (*bed->elf_backend_modify_segment_map) (abfd, link_info))
4077         return FALSE;
4078     }
4079
4080   count = 0;
4081   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4082     ++count;
4083
4084   elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4085   elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4086   elf_elfheader (abfd)->e_phnum = count;
4087
4088   if (count == 0)
4089     {
4090       elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4091       return TRUE;
4092     }
4093
4094   /* If we already counted the number of program segments, make sure
4095      that we allocated enough space.  This happens when SIZEOF_HEADERS
4096      is used in a linker script.  */
4097   alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
4098   if (alloc != 0 && count > alloc)
4099     {
4100       ((*_bfd_error_handler)
4101        (_("%B: Not enough room for program headers (allocated %u, need %u)"),
4102         abfd, alloc, count));
4103       bfd_set_error (bfd_error_bad_value);
4104       return FALSE;
4105     }
4106
4107   if (alloc == 0)
4108     alloc = count;
4109
4110   phdrs = bfd_alloc2 (abfd, alloc, sizeof (Elf_Internal_Phdr));
4111   if (phdrs == NULL)
4112     return FALSE;
4113
4114   off = bed->s->sizeof_ehdr;
4115   off += alloc * bed->s->sizeof_phdr;
4116
4117   filehdr_vaddr = 0;
4118   filehdr_paddr = 0;
4119   phdrs_vaddr = 0;
4120   phdrs_paddr = 0;
4121
4122   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4123        m != NULL;
4124        m = m->next, p++)
4125     {
4126       unsigned int i;
4127       asection **secpp;
4128
4129       /* If elf_segment_map is not from map_sections_to_segments, the
4130          sections may not be correctly ordered.  NOTE: sorting should
4131          not be done to the PT_NOTE section of a corefile, which may
4132          contain several pseudo-sections artificially created by bfd.
4133          Sorting these pseudo-sections breaks things badly.  */
4134       if (m->count > 1
4135           && !(elf_elfheader (abfd)->e_type == ET_CORE
4136                && m->p_type == PT_NOTE))
4137         qsort (m->sections, (size_t) m->count, sizeof (asection *),
4138                elf_sort_sections);
4139
4140       /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4141          number of sections with contents contributing to both p_filesz
4142          and p_memsz, followed by a number of sections with no contents
4143          that just contribute to p_memsz.  In this loop, OFF tracks next
4144          available file offset for PT_LOAD and PT_NOTE segments.  VOFF is
4145          an adjustment we use for segments that have no file contents
4146          but need zero filled memory allocation.  */
4147       voff = 0;
4148       p->p_type = m->p_type;
4149       p->p_flags = m->p_flags;
4150
4151       if (p->p_type == PT_LOAD
4152           && m->count > 0)
4153         {
4154           bfd_size_type align;
4155           bfd_vma adjust;
4156           unsigned int align_power = 0;
4157
4158           for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4159             {
4160               unsigned int secalign;
4161
4162               secalign = bfd_get_section_alignment (abfd, *secpp);
4163               if (secalign > align_power)
4164                 align_power = secalign;
4165             }
4166           align = (bfd_size_type) 1 << align_power;
4167
4168           if ((abfd->flags & D_PAGED) != 0 && bed->maxpagesize > align)
4169             align = bed->maxpagesize;
4170
4171           adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4172           off += adjust;
4173           if (adjust != 0
4174               && !m->includes_filehdr
4175               && !m->includes_phdrs
4176               && (ufile_ptr) off >= align)
4177             {
4178               /* If the first section isn't loadable, the same holds for
4179                  any other sections.  Since the segment won't need file
4180                  space, we can make p_offset overlap some prior segment.
4181                  However, .tbss is special.  If a segment starts with
4182                  .tbss, we need to look at the next section to decide
4183                  whether the segment has any loadable sections.  */
4184               i = 0;
4185               while ((m->sections[i]->flags & SEC_LOAD) == 0)
4186                 {
4187                   if ((m->sections[i]->flags & SEC_THREAD_LOCAL) == 0
4188                       || ++i >= m->count)
4189                     {
4190                       off -= adjust;
4191                       voff = adjust - align;
4192                       break;
4193                     }
4194                 }
4195             }
4196         }
4197       /* Make sure the .dynamic section is the first section in the
4198          PT_DYNAMIC segment.  */
4199       else if (p->p_type == PT_DYNAMIC
4200                && m->count > 1
4201                && strcmp (m->sections[0]->name, ".dynamic") != 0)
4202         {
4203           _bfd_error_handler
4204             (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4205              abfd);
4206           bfd_set_error (bfd_error_bad_value);
4207           return FALSE;
4208         }
4209
4210       if (m->count == 0)
4211         p->p_vaddr = 0;
4212       else
4213         p->p_vaddr = m->sections[0]->vma;
4214
4215       if (m->p_paddr_valid)
4216         p->p_paddr = m->p_paddr;
4217       else if (m->count == 0)
4218         p->p_paddr = 0;
4219       else
4220         p->p_paddr = m->sections[0]->lma;
4221
4222       if (p->p_type == PT_LOAD
4223           && (abfd->flags & D_PAGED) != 0)
4224         p->p_align = bed->maxpagesize;
4225       else if (m->count == 0)
4226         p->p_align = 1 << bed->s->log_file_align;
4227       else
4228         p->p_align = 0;
4229
4230       p->p_offset = 0;
4231       p->p_filesz = 0;
4232       p->p_memsz = 0;
4233
4234       if (m->includes_filehdr)
4235         {
4236           if (! m->p_flags_valid)
4237             p->p_flags |= PF_R;
4238           p->p_offset = 0;
4239           p->p_filesz = bed->s->sizeof_ehdr;
4240           p->p_memsz = bed->s->sizeof_ehdr;
4241           if (m->count > 0)
4242             {
4243               BFD_ASSERT (p->p_type == PT_LOAD);
4244
4245               if (p->p_vaddr < (bfd_vma) off)
4246                 {
4247                   (*_bfd_error_handler)
4248                     (_("%B: Not enough room for program headers, try linking with -N"),
4249                      abfd);
4250                   bfd_set_error (bfd_error_bad_value);
4251                   return FALSE;
4252                 }
4253
4254               p->p_vaddr -= off;
4255               if (! m->p_paddr_valid)
4256                 p->p_paddr -= off;
4257             }
4258           if (p->p_type == PT_LOAD)
4259             {
4260               filehdr_vaddr = p->p_vaddr;
4261               filehdr_paddr = p->p_paddr;
4262             }
4263         }
4264
4265       if (m->includes_phdrs)
4266         {
4267           if (! m->p_flags_valid)
4268             p->p_flags |= PF_R;
4269
4270           if (m->includes_filehdr)
4271             {
4272               if (p->p_type == PT_LOAD)
4273                 {
4274                   phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
4275                   phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
4276                 }
4277             }
4278           else
4279             {
4280               p->p_offset = bed->s->sizeof_ehdr;
4281
4282               if (m->count > 0)
4283                 {
4284                   BFD_ASSERT (p->p_type == PT_LOAD);
4285                   p->p_vaddr -= off - p->p_offset;
4286                   if (! m->p_paddr_valid)
4287                     p->p_paddr -= off - p->p_offset;
4288                 }
4289
4290               if (p->p_type == PT_LOAD)
4291                 {
4292                   phdrs_vaddr = p->p_vaddr;
4293                   phdrs_paddr = p->p_paddr;
4294                 }
4295               else
4296                 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4297             }
4298
4299           p->p_filesz += alloc * bed->s->sizeof_phdr;
4300           p->p_memsz += alloc * bed->s->sizeof_phdr;
4301         }
4302
4303       if (p->p_type == PT_LOAD
4304           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4305         {
4306           if (! m->includes_filehdr && ! m->includes_phdrs)
4307             p->p_offset = off + voff;
4308           else
4309             {
4310               file_ptr adjust;
4311
4312               adjust = off - (p->p_offset + p->p_filesz);
4313               p->p_filesz += adjust;
4314               p->p_memsz += adjust;
4315             }
4316         }
4317
4318       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4319         {
4320           asection *sec;
4321           flagword flags;
4322           bfd_size_type align;
4323
4324           sec = *secpp;
4325           flags = sec->flags;
4326           align = 1 << bfd_get_section_alignment (abfd, sec);
4327
4328           if (p->p_type == PT_LOAD
4329               || p->p_type == PT_TLS)
4330             {
4331               bfd_signed_vma adjust;
4332
4333               if ((flags & SEC_LOAD) != 0)
4334                 {
4335                   adjust = sec->lma - (p->p_paddr + p->p_filesz);
4336                   if (adjust < 0)
4337                     {
4338                       (*_bfd_error_handler)
4339                         (_("%B: section %A lma 0x%lx overlaps previous sections"),
4340                          abfd, sec, (unsigned long) sec->lma);
4341                       adjust = 0;
4342                     }
4343                   off += adjust;
4344                   p->p_filesz += adjust;
4345                   p->p_memsz += adjust;
4346                 }
4347               /* .tbss is special.  It doesn't contribute to p_memsz of
4348                  normal segments.  */
4349               else if ((flags & SEC_THREAD_LOCAL) == 0
4350                        || p->p_type == PT_TLS)
4351                 {
4352                   /* The section VMA must equal the file position
4353                      modulo the page size.  */
4354                   bfd_size_type page = align;
4355                   if ((abfd->flags & D_PAGED) != 0 && bed->maxpagesize > page)
4356                     page = bed->maxpagesize;
4357                   adjust = vma_page_aligned_bias (sec->vma,
4358                                                   p->p_vaddr + p->p_memsz,
4359                                                   page);
4360                   p->p_memsz += adjust;
4361                 }
4362             }
4363
4364           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4365             {
4366               /* The section at i == 0 is the one that actually contains
4367                  everything.  */
4368               if (i == 0)
4369                 {
4370                   sec->filepos = off;
4371                   off += sec->size;
4372                   p->p_filesz = sec->size;
4373                   p->p_memsz = 0;
4374                   p->p_align = 1;
4375                 }
4376               else
4377                 {
4378                   /* The rest are fake sections that shouldn't be written.  */
4379                   sec->filepos = 0;
4380                   sec->size = 0;
4381                   sec->flags = 0;
4382                   continue;
4383                 }
4384             }
4385           else
4386             {
4387               if (p->p_type == PT_LOAD)
4388                 {
4389                   sec->filepos = off;
4390                   /* FIXME: The SEC_HAS_CONTENTS test here dates back to
4391                      1997, and the exact reason for it isn't clear.  One
4392                      plausible explanation is that it is to work around
4393                      a problem we have with linker scripts using data
4394                      statements in NOLOAD sections.  I don't think it
4395                      makes a great deal of sense to have such a section
4396                      assigned to a PT_LOAD segment, but apparently
4397                      people do this.  The data statement results in a
4398                      bfd_data_link_order being built, and these need
4399                      section contents to write into.  Eventually, we get
4400                      to _bfd_elf_write_object_contents which writes any
4401                      section with contents to the output.  Make room
4402                      here for the write, so that following segments are
4403                      not trashed.  */
4404                   if ((flags & SEC_LOAD) != 0
4405                       || (flags & SEC_HAS_CONTENTS) != 0)
4406                     off += sec->size;
4407                 }
4408
4409               if ((flags & SEC_LOAD) != 0)
4410                 {
4411                   p->p_filesz += sec->size;
4412                   p->p_memsz += sec->size;
4413                 }
4414               /* PR ld/594:  Sections in note segments which are not loaded
4415                  contribute to the file size but not the in-memory size.  */
4416               else if (p->p_type == PT_NOTE
4417                   && (flags & SEC_HAS_CONTENTS) != 0)
4418                 p->p_filesz += sec->size;
4419
4420               /* .tbss is special.  It doesn't contribute to p_memsz of
4421                  normal segments.  */
4422               else if ((flags & SEC_THREAD_LOCAL) == 0
4423                        || p->p_type == PT_TLS)
4424                 p->p_memsz += sec->size;
4425
4426               if (p->p_type == PT_TLS
4427                   && sec->size == 0
4428                   && (sec->flags & SEC_HAS_CONTENTS) == 0)
4429                 {
4430                   struct bfd_link_order *o = sec->map_tail.link_order;
4431                   if (o != NULL)
4432                     p->p_memsz += o->offset + o->size;
4433                 }
4434
4435               if (align > p->p_align
4436                   && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
4437                 p->p_align = align;
4438             }
4439
4440           if (! m->p_flags_valid)
4441             {
4442               p->p_flags |= PF_R;
4443               if ((flags & SEC_CODE) != 0)
4444                 p->p_flags |= PF_X;
4445               if ((flags & SEC_READONLY) == 0)
4446                 p->p_flags |= PF_W;
4447             }
4448         }
4449     }
4450
4451   /* Now that we have set the section file positions, we can set up
4452      the file positions for the non PT_LOAD segments.  */
4453   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4454        m != NULL;
4455        m = m->next, p++)
4456     {
4457       if (p->p_type != PT_LOAD && m->count > 0)
4458         {
4459           BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
4460           /* If the section has not yet been assigned a file position,
4461              do so now.  The ARM BPABI requires that .dynamic section
4462              not be marked SEC_ALLOC because it is not part of any
4463              PT_LOAD segment, so it will not be processed above.  */
4464           if (p->p_type == PT_DYNAMIC && m->sections[0]->filepos == 0)
4465             {
4466               unsigned int i;
4467               Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4468
4469               i = 1;
4470               while (i_shdrpp[i]->bfd_section != m->sections[0])
4471                 ++i;
4472               off = (_bfd_elf_assign_file_position_for_section
4473                      (i_shdrpp[i], off, TRUE));
4474               p->p_filesz = m->sections[0]->size;
4475             }
4476           p->p_offset = m->sections[0]->filepos;
4477         }
4478       if (m->count == 0)
4479         {
4480           if (m->includes_filehdr)
4481             {
4482               p->p_vaddr = filehdr_vaddr;
4483               if (! m->p_paddr_valid)
4484                 p->p_paddr = filehdr_paddr;
4485             }
4486           else if (m->includes_phdrs)
4487             {
4488               p->p_vaddr = phdrs_vaddr;
4489               if (! m->p_paddr_valid)
4490                 p->p_paddr = phdrs_paddr;
4491             }
4492           else if (p->p_type == PT_GNU_RELRO)
4493             {
4494               Elf_Internal_Phdr *lp;
4495
4496               for (lp = phdrs; lp < phdrs + count; ++lp)
4497                 {
4498                   if (lp->p_type == PT_LOAD
4499                       && lp->p_vaddr <= link_info->relro_end
4500                       && lp->p_vaddr >= link_info->relro_start
4501                       && lp->p_vaddr + lp->p_filesz
4502                          >= link_info->relro_end)
4503                     break;
4504                 }
4505
4506               if (lp < phdrs + count
4507                   && link_info->relro_end > lp->p_vaddr)
4508                 {
4509                   p->p_vaddr = lp->p_vaddr;
4510                   p->p_paddr = lp->p_paddr;
4511                   p->p_offset = lp->p_offset;
4512                   p->p_filesz = link_info->relro_end - lp->p_vaddr;
4513                   p->p_memsz = p->p_filesz;
4514                   p->p_align = 1;
4515                   p->p_flags = (lp->p_flags & ~PF_W);
4516                 }
4517               else
4518                 {
4519                   memset (p, 0, sizeof *p);
4520                   p->p_type = PT_NULL;
4521                 }
4522             }
4523         }
4524     }
4525
4526   /* Clear out any program headers we allocated but did not use.  */
4527   for (; count < alloc; count++, p++)
4528     {
4529       memset (p, 0, sizeof *p);
4530       p->p_type = PT_NULL;
4531     }
4532
4533   elf_tdata (abfd)->phdr = phdrs;
4534
4535   elf_tdata (abfd)->next_file_pos = off;
4536
4537   /* Write out the program headers.  */
4538   if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4539       || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
4540     return FALSE;
4541
4542   return TRUE;
4543 }
4544
4545 /* Get the size of the program header.
4546
4547    If this is called by the linker before any of the section VMA's are set, it
4548    can't calculate the correct value for a strange memory layout.  This only
4549    happens when SIZEOF_HEADERS is used in a linker script.  In this case,
4550    SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4551    data segment (exclusive of .interp and .dynamic).
4552
4553    ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4554    will be two segments.  */
4555
4556 static bfd_size_type
4557 get_program_header_size (bfd *abfd)
4558 {
4559   size_t segs;
4560   asection *s;
4561   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4562
4563   /* We can't return a different result each time we're called.  */
4564   if (elf_tdata (abfd)->program_header_size != 0)
4565     return elf_tdata (abfd)->program_header_size;
4566
4567   if (elf_tdata (abfd)->segment_map != NULL)
4568     {
4569       struct elf_segment_map *m;
4570
4571       segs = 0;
4572       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4573         ++segs;
4574       elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4575       return elf_tdata (abfd)->program_header_size;
4576     }
4577
4578   /* Assume we will need exactly two PT_LOAD segments: one for text
4579      and one for data.  */
4580   segs = 2;
4581
4582   s = bfd_get_section_by_name (abfd, ".interp");
4583   if (s != NULL && (s->flags & SEC_LOAD) != 0)
4584     {
4585       /* If we have a loadable interpreter section, we need a
4586          PT_INTERP segment.  In this case, assume we also need a
4587          PT_PHDR segment, although that may not be true for all
4588          targets.  */
4589       segs += 2;
4590     }
4591
4592   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4593     {
4594       /* We need a PT_DYNAMIC segment.  */
4595       ++segs;
4596     }
4597
4598   if (elf_tdata (abfd)->eh_frame_hdr)
4599     {
4600       /* We need a PT_GNU_EH_FRAME segment.  */
4601       ++segs;
4602     }
4603
4604   if (elf_tdata (abfd)->stack_flags)
4605     {
4606       /* We need a PT_GNU_STACK segment.  */
4607       ++segs;
4608     }
4609
4610   if (elf_tdata (abfd)->relro)
4611     {
4612       /* We need a PT_GNU_RELRO segment.  */
4613       ++segs;
4614     }
4615
4616   for (s = abfd->sections; s != NULL; s = s->next)
4617     {
4618       if ((s->flags & SEC_LOAD) != 0
4619           && strncmp (s->name, ".note", 5) == 0)
4620         {
4621           /* We need a PT_NOTE segment.  */
4622           ++segs;
4623         }
4624     }
4625
4626   for (s = abfd->sections; s != NULL; s = s->next)
4627     {
4628       if (s->flags & SEC_THREAD_LOCAL)
4629         {
4630           /* We need a PT_TLS segment.  */
4631           ++segs;
4632           break;
4633         }
4634     }
4635
4636   /* Let the backend count up any program headers it might need.  */
4637   if (bed->elf_backend_additional_program_headers)
4638     {
4639       int a;
4640
4641       a = (*bed->elf_backend_additional_program_headers) (abfd);
4642       if (a == -1)
4643         abort ();
4644       segs += a;
4645     }
4646
4647   elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4648   return elf_tdata (abfd)->program_header_size;
4649 }
4650
4651 /* Work out the file positions of all the sections.  This is called by
4652    _bfd_elf_compute_section_file_positions.  All the section sizes and
4653    VMAs must be known before this is called.
4654
4655    Reloc sections come in two flavours: Those processed specially as
4656    "side-channel" data attached to a section to which they apply, and
4657    those that bfd doesn't process as relocations.  The latter sort are
4658    stored in a normal bfd section by bfd_section_from_shdr.   We don't
4659    consider the former sort here, unless they form part of the loadable
4660    image.  Reloc sections not assigned here will be handled later by
4661    assign_file_positions_for_relocs.
4662
4663    We also don't set the positions of the .symtab and .strtab here.  */
4664
4665 static bfd_boolean
4666 assign_file_positions_except_relocs (bfd *abfd,
4667                                      struct bfd_link_info *link_info)
4668 {
4669   struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4670   Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4671   Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4672   unsigned int num_sec = elf_numsections (abfd);
4673   file_ptr off;
4674   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4675
4676   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4677       && bfd_get_format (abfd) != bfd_core)
4678     {
4679       Elf_Internal_Shdr **hdrpp;
4680       unsigned int i;
4681
4682       /* Start after the ELF header.  */
4683       off = i_ehdrp->e_ehsize;
4684
4685       /* We are not creating an executable, which means that we are
4686          not creating a program header, and that the actual order of
4687          the sections in the file is unimportant.  */
4688       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4689         {
4690           Elf_Internal_Shdr *hdr;
4691
4692           hdr = *hdrpp;
4693           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4694                && hdr->bfd_section == NULL)
4695               || i == tdata->symtab_section
4696               || i == tdata->symtab_shndx_section
4697               || i == tdata->strtab_section)
4698             {
4699               hdr->sh_offset = -1;
4700             }
4701           else
4702             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4703
4704           if (i == SHN_LORESERVE - 1)
4705             {
4706               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4707               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4708             }
4709         }
4710     }
4711   else
4712     {
4713       unsigned int i;
4714       Elf_Internal_Shdr **hdrpp;
4715
4716       /* Assign file positions for the loaded sections based on the
4717          assignment of sections to segments.  */
4718       if (! assign_file_positions_for_segments (abfd, link_info))
4719         return FALSE;
4720
4721       /* Assign file positions for the other sections.  */
4722
4723       off = elf_tdata (abfd)->next_file_pos;
4724       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4725         {
4726           Elf_Internal_Shdr *hdr;
4727
4728           hdr = *hdrpp;
4729           if (hdr->bfd_section != NULL
4730               && hdr->bfd_section->filepos != 0)
4731             hdr->sh_offset = hdr->bfd_section->filepos;
4732           else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4733             {
4734               ((*_bfd_error_handler)
4735                (_("%B: warning: allocated section `%s' not in segment"),
4736                 abfd,
4737                 (hdr->bfd_section == NULL
4738                  ? "*unknown*"
4739                  : hdr->bfd_section->name)));
4740               if ((abfd->flags & D_PAGED) != 0)
4741                 off += vma_page_aligned_bias (hdr->sh_addr, off,
4742                                               bed->maxpagesize);
4743               else
4744                 off += vma_page_aligned_bias (hdr->sh_addr, off,
4745                                               hdr->sh_addralign);
4746               off = _bfd_elf_assign_file_position_for_section (hdr, off,
4747                                                                FALSE);
4748             }
4749           else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4750                     && hdr->bfd_section == NULL)
4751                    || hdr == i_shdrpp[tdata->symtab_section]
4752                    || hdr == i_shdrpp[tdata->symtab_shndx_section]
4753                    || hdr == i_shdrpp[tdata->strtab_section])
4754             hdr->sh_offset = -1;
4755           else
4756             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4757
4758           if (i == SHN_LORESERVE - 1)
4759             {
4760               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4761               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4762             }
4763         }
4764     }
4765
4766   /* Place the section headers.  */
4767   off = align_file_position (off, 1 << bed->s->log_file_align);
4768   i_ehdrp->e_shoff = off;
4769   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4770
4771   elf_tdata (abfd)->next_file_pos = off;
4772
4773   return TRUE;
4774 }
4775
4776 static bfd_boolean
4777 prep_headers (bfd *abfd)
4778 {
4779   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
4780   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4781   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
4782   struct elf_strtab_hash *shstrtab;
4783   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4784
4785   i_ehdrp = elf_elfheader (abfd);
4786   i_shdrp = elf_elfsections (abfd);
4787
4788   shstrtab = _bfd_elf_strtab_init ();
4789   if (shstrtab == NULL)
4790     return FALSE;
4791
4792   elf_shstrtab (abfd) = shstrtab;
4793
4794   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4795   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4796   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4797   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4798
4799   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4800   i_ehdrp->e_ident[EI_DATA] =
4801     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4802   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4803
4804   if ((abfd->flags & DYNAMIC) != 0)
4805     i_ehdrp->e_type = ET_DYN;
4806   else if ((abfd->flags & EXEC_P) != 0)
4807     i_ehdrp->e_type = ET_EXEC;
4808   else if (bfd_get_format (abfd) == bfd_core)
4809     i_ehdrp->e_type = ET_CORE;
4810   else
4811     i_ehdrp->e_type = ET_REL;
4812
4813   switch (bfd_get_arch (abfd))
4814     {
4815     case bfd_arch_unknown:
4816       i_ehdrp->e_machine = EM_NONE;
4817       break;
4818
4819       /* There used to be a long list of cases here, each one setting
4820          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4821          in the corresponding bfd definition.  To avoid duplication,
4822          the switch was removed.  Machines that need special handling
4823          can generally do it in elf_backend_final_write_processing(),
4824          unless they need the information earlier than the final write.
4825          Such need can generally be supplied by replacing the tests for
4826          e_machine with the conditions used to determine it.  */
4827     default:
4828       i_ehdrp->e_machine = bed->elf_machine_code;
4829     }
4830
4831   i_ehdrp->e_version = bed->s->ev_current;
4832   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4833
4834   /* No program header, for now.  */
4835   i_ehdrp->e_phoff = 0;
4836   i_ehdrp->e_phentsize = 0;
4837   i_ehdrp->e_phnum = 0;
4838
4839   /* Each bfd section is section header entry.  */
4840   i_ehdrp->e_entry = bfd_get_start_address (abfd);
4841   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4842
4843   /* If we're building an executable, we'll need a program header table.  */
4844   if (abfd->flags & EXEC_P)
4845     /* It all happens later.  */
4846     ;
4847   else
4848     {
4849       i_ehdrp->e_phentsize = 0;
4850       i_phdrp = 0;
4851       i_ehdrp->e_phoff = 0;
4852     }
4853
4854   elf_tdata (abfd)->symtab_hdr.sh_name =
4855     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4856   elf_tdata (abfd)->strtab_hdr.sh_name =
4857     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4858   elf_tdata (abfd)->shstrtab_hdr.sh_name =
4859     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4860   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4861       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4862       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4863     return FALSE;
4864
4865   return TRUE;
4866 }
4867
4868 /* Assign file positions for all the reloc sections which are not part
4869    of the loadable file image.  */
4870
4871 void
4872 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4873 {
4874   file_ptr off;
4875   unsigned int i, num_sec;
4876   Elf_Internal_Shdr **shdrpp;
4877
4878   off = elf_tdata (abfd)->next_file_pos;
4879
4880   num_sec = elf_numsections (abfd);
4881   for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4882     {
4883       Elf_Internal_Shdr *shdrp;
4884
4885       shdrp = *shdrpp;
4886       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4887           && shdrp->sh_offset == -1)
4888         off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4889     }
4890
4891   elf_tdata (abfd)->next_file_pos = off;
4892 }
4893
4894 bfd_boolean
4895 _bfd_elf_write_object_contents (bfd *abfd)
4896 {
4897   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4898   Elf_Internal_Ehdr *i_ehdrp;
4899   Elf_Internal_Shdr **i_shdrp;
4900   bfd_boolean failed;
4901   unsigned int count, num_sec;
4902
4903   if (! abfd->output_has_begun
4904       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4905     return FALSE;
4906
4907   i_shdrp = elf_elfsections (abfd);
4908   i_ehdrp = elf_elfheader (abfd);
4909
4910   failed = FALSE;
4911   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4912   if (failed)
4913     return FALSE;
4914
4915   _bfd_elf_assign_file_positions_for_relocs (abfd);
4916
4917   /* After writing the headers, we need to write the sections too...  */
4918   num_sec = elf_numsections (abfd);
4919   for (count = 1; count < num_sec; count++)
4920     {
4921       if (bed->elf_backend_section_processing)
4922         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4923       if (i_shdrp[count]->contents)
4924         {
4925           bfd_size_type amt = i_shdrp[count]->sh_size;
4926
4927           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4928               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4929             return FALSE;
4930         }
4931       if (count == SHN_LORESERVE - 1)
4932         count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4933     }
4934
4935   /* Write out the section header names.  */
4936   if (elf_shstrtab (abfd) != NULL
4937       && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4938           || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
4939     return FALSE;
4940
4941   if (bed->elf_backend_final_write_processing)
4942     (*bed->elf_backend_final_write_processing) (abfd,
4943                                                 elf_tdata (abfd)->linker);
4944
4945   return bed->s->write_shdrs_and_ehdr (abfd);
4946 }
4947
4948 bfd_boolean
4949 _bfd_elf_write_corefile_contents (bfd *abfd)
4950 {
4951   /* Hopefully this can be done just like an object file.  */
4952   return _bfd_elf_write_object_contents (abfd);
4953 }
4954
4955 /* Given a section, search the header to find them.  */
4956
4957 int
4958 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
4959 {
4960   const struct elf_backend_data *bed;
4961   int index;
4962
4963   if (elf_section_data (asect) != NULL
4964       && elf_section_data (asect)->this_idx != 0)
4965     return elf_section_data (asect)->this_idx;
4966
4967   if (bfd_is_abs_section (asect))
4968     index = SHN_ABS;
4969   else if (bfd_is_com_section (asect))
4970     index = SHN_COMMON;
4971   else if (bfd_is_und_section (asect))
4972     index = SHN_UNDEF;
4973   else
4974     index = -1;
4975
4976   bed = get_elf_backend_data (abfd);
4977   if (bed->elf_backend_section_from_bfd_section)
4978     {
4979       int retval = index;
4980
4981       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4982         return retval;
4983     }
4984
4985   if (index == -1)
4986     bfd_set_error (bfd_error_nonrepresentable_section);
4987
4988   return index;
4989 }
4990
4991 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4992    on error.  */
4993
4994 int
4995 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
4996 {
4997   asymbol *asym_ptr = *asym_ptr_ptr;
4998   int idx;
4999   flagword flags = asym_ptr->flags;
5000
5001   /* When gas creates relocations against local labels, it creates its
5002      own symbol for the section, but does put the symbol into the
5003      symbol chain, so udata is 0.  When the linker is generating
5004      relocatable output, this section symbol may be for one of the
5005      input sections rather than the output section.  */
5006   if (asym_ptr->udata.i == 0
5007       && (flags & BSF_SECTION_SYM)
5008       && asym_ptr->section)
5009     {
5010       int indx;
5011
5012       if (asym_ptr->section->output_section != NULL)
5013         indx = asym_ptr->section->output_section->index;
5014       else
5015         indx = asym_ptr->section->index;
5016       if (indx < elf_num_section_syms (abfd)
5017           && elf_section_syms (abfd)[indx] != NULL)
5018         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5019     }
5020
5021   idx = asym_ptr->udata.i;
5022
5023   if (idx == 0)
5024     {
5025       /* This case can occur when using --strip-symbol on a symbol
5026          which is used in a relocation entry.  */
5027       (*_bfd_error_handler)
5028         (_("%B: symbol `%s' required but not present"),
5029          abfd, bfd_asymbol_name (asym_ptr));
5030       bfd_set_error (bfd_error_no_symbols);
5031       return -1;
5032     }
5033
5034 #if DEBUG & 4
5035   {
5036     fprintf (stderr,
5037              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5038              (long) asym_ptr, asym_ptr->name, idx, flags,
5039              elf_symbol_flags (flags));
5040     fflush (stderr);
5041   }
5042 #endif
5043
5044   return idx;
5045 }
5046
5047 /* Copy private BFD data.  This copies any program header information.  */
5048
5049 static bfd_boolean
5050 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5051 {
5052   Elf_Internal_Ehdr *iehdr;
5053   struct elf_segment_map *map;
5054   struct elf_segment_map *map_first;
5055   struct elf_segment_map **pointer_to_map;
5056   Elf_Internal_Phdr *segment;
5057   asection *section;
5058   unsigned int i;
5059   unsigned int num_segments;
5060   bfd_boolean phdr_included = FALSE;
5061   bfd_vma maxpagesize;
5062   struct elf_segment_map *phdr_adjust_seg = NULL;
5063   unsigned int phdr_adjust_num = 0;
5064   const struct elf_backend_data *bed;
5065
5066   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5067       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5068     return TRUE;
5069
5070   if (elf_tdata (ibfd)->phdr == NULL)
5071     return TRUE;
5072
5073   bed = get_elf_backend_data (ibfd);
5074   iehdr = elf_elfheader (ibfd);
5075
5076   map_first = NULL;
5077   pointer_to_map = &map_first;
5078
5079   num_segments = elf_elfheader (ibfd)->e_phnum;
5080   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5081
5082   /* Returns the end address of the segment + 1.  */
5083 #define SEGMENT_END(segment, start)                                     \
5084   (start + (segment->p_memsz > segment->p_filesz                        \
5085             ? segment->p_memsz : segment->p_filesz))
5086
5087 #define SECTION_SIZE(section, segment)                                  \
5088   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
5089     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
5090    ? section->size : 0)
5091
5092   /* Returns TRUE if the given section is contained within
5093      the given segment.  VMA addresses are compared.  */
5094 #define IS_CONTAINED_BY_VMA(section, segment)                           \
5095   (section->vma >= segment->p_vaddr                                     \
5096    && (section->vma + SECTION_SIZE (section, segment)                   \
5097        <= (SEGMENT_END (segment, segment->p_vaddr))))
5098
5099   /* Returns TRUE if the given section is contained within
5100      the given segment.  LMA addresses are compared.  */
5101 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
5102   (section->lma >= base                                                 \
5103    && (section->lma + SECTION_SIZE (section, segment)                   \
5104        <= SEGMENT_END (segment, base)))
5105
5106   /* Special case: corefile "NOTE" section containing regs, prpsinfo etc.  */
5107 #define IS_COREFILE_NOTE(p, s)                                          \
5108   (p->p_type == PT_NOTE                                                 \
5109    && bfd_get_format (ibfd) == bfd_core                                 \
5110    && s->vma == 0 && s->lma == 0                                        \
5111    && (bfd_vma) s->filepos >= p->p_offset                               \
5112    && ((bfd_vma) s->filepos + s->size                           \
5113        <= p->p_offset + p->p_filesz))
5114
5115   /* The complicated case when p_vaddr is 0 is to handle the Solaris
5116      linker, which generates a PT_INTERP section with p_vaddr and
5117      p_memsz set to 0.  */
5118 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
5119   (p->p_vaddr == 0                                                      \
5120    && p->p_paddr == 0                                                   \
5121    && p->p_memsz == 0                                                   \
5122    && p->p_filesz > 0                                                   \
5123    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
5124    && s->size > 0                                                       \
5125    && (bfd_vma) s->filepos >= p->p_offset                               \
5126    && ((bfd_vma) s->filepos + s->size                           \
5127        <= p->p_offset + p->p_filesz))
5128
5129   /* Decide if the given section should be included in the given segment.
5130      A section will be included if:
5131        1. It is within the address space of the segment -- we use the LMA
5132           if that is set for the segment and the VMA otherwise,
5133        2. It is an allocated segment,
5134        3. There is an output section associated with it,
5135        4. The section has not already been allocated to a previous segment.
5136        5. PT_GNU_STACK segments do not include any sections.
5137        6. PT_TLS segment includes only SHF_TLS sections.
5138        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5139        8. PT_DYNAMIC should not contain empty sections at the beginning
5140           (with the possible exception of .dynamic).  */
5141 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
5142   ((((segment->p_paddr                                                  \
5143       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
5144       : IS_CONTAINED_BY_VMA (section, segment))                         \
5145      && (section->flags & SEC_ALLOC) != 0)                              \
5146     || IS_COREFILE_NOTE (segment, section))                             \
5147    && section->output_section != NULL                                   \
5148    && segment->p_type != PT_GNU_STACK                                   \
5149    && (segment->p_type != PT_TLS                                        \
5150        || (section->flags & SEC_THREAD_LOCAL))                          \
5151    && (segment->p_type == PT_LOAD                                       \
5152        || segment->p_type == PT_TLS                                     \
5153        || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
5154    && (segment->p_type != PT_DYNAMIC                                    \
5155        || SECTION_SIZE (section, segment) > 0                           \
5156        || (segment->p_paddr                                             \
5157            ? segment->p_paddr != section->lma                           \
5158            : segment->p_vaddr != section->vma)                          \
5159        || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic")    \
5160            == 0))                                                       \
5161    && ! section->segment_mark)
5162
5163   /* Returns TRUE iff seg1 starts after the end of seg2.  */
5164 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
5165   (seg1->field >= SEGMENT_END (seg2, seg2->field))
5166
5167   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5168      their VMA address ranges and their LMA address ranges overlap.
5169      It is possible to have overlapping VMA ranges without overlapping LMA
5170      ranges.  RedBoot images for example can have both .data and .bss mapped
5171      to the same VMA range, but with the .data section mapped to a different
5172      LMA.  */
5173 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
5174   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
5175         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
5176    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
5177         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5178
5179   /* Initialise the segment mark field.  */
5180   for (section = ibfd->sections; section != NULL; section = section->next)
5181     section->segment_mark = FALSE;
5182
5183   /* Scan through the segments specified in the program header
5184      of the input BFD.  For this first scan we look for overlaps
5185      in the loadable segments.  These can be created by weird
5186      parameters to objcopy.  Also, fix some solaris weirdness.  */
5187   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5188        i < num_segments;
5189        i++, segment++)
5190     {
5191       unsigned int j;
5192       Elf_Internal_Phdr *segment2;
5193
5194       if (segment->p_type == PT_INTERP)
5195         for (section = ibfd->sections; section; section = section->next)
5196           if (IS_SOLARIS_PT_INTERP (segment, section))
5197             {
5198               /* Mininal change so that the normal section to segment
5199                  assignment code will work.  */
5200               segment->p_vaddr = section->vma;
5201               break;
5202             }
5203
5204       if (segment->p_type != PT_LOAD)
5205         continue;
5206
5207       /* Determine if this segment overlaps any previous segments.  */
5208       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
5209         {
5210           bfd_signed_vma extra_length;
5211
5212           if (segment2->p_type != PT_LOAD
5213               || ! SEGMENT_OVERLAPS (segment, segment2))
5214             continue;
5215
5216           /* Merge the two segments together.  */
5217           if (segment2->p_vaddr < segment->p_vaddr)
5218             {
5219               /* Extend SEGMENT2 to include SEGMENT and then delete
5220                  SEGMENT.  */
5221               extra_length =
5222                 SEGMENT_END (segment, segment->p_vaddr)
5223                 - SEGMENT_END (segment2, segment2->p_vaddr);
5224
5225               if (extra_length > 0)
5226                 {
5227                   segment2->p_memsz  += extra_length;
5228                   segment2->p_filesz += extra_length;
5229                 }
5230
5231               segment->p_type = PT_NULL;
5232
5233               /* Since we have deleted P we must restart the outer loop.  */
5234               i = 0;
5235               segment = elf_tdata (ibfd)->phdr;
5236               break;
5237             }
5238           else
5239             {
5240               /* Extend SEGMENT to include SEGMENT2 and then delete
5241                  SEGMENT2.  */
5242               extra_length =
5243                 SEGMENT_END (segment2, segment2->p_vaddr)
5244                 - SEGMENT_END (segment, segment->p_vaddr);
5245
5246               if (extra_length > 0)
5247                 {
5248                   segment->p_memsz  += extra_length;
5249                   segment->p_filesz += extra_length;
5250                 }
5251
5252               segment2->p_type = PT_NULL;
5253             }
5254         }
5255     }
5256
5257   /* The second scan attempts to assign sections to segments.  */
5258   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5259        i < num_segments;
5260        i ++, segment ++)
5261     {
5262       unsigned int  section_count;
5263       asection **   sections;
5264       asection *    output_section;
5265       unsigned int  isec;
5266       bfd_vma       matching_lma;
5267       bfd_vma       suggested_lma;
5268       unsigned int  j;
5269       bfd_size_type amt;
5270
5271       if (segment->p_type == PT_NULL)
5272         continue;
5273
5274       /* Compute how many sections might be placed into this segment.  */
5275       for (section = ibfd->sections, section_count = 0;
5276            section != NULL;
5277            section = section->next)
5278         if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5279           ++section_count;
5280
5281       /* Allocate a segment map big enough to contain
5282          all of the sections we have selected.  */
5283       amt = sizeof (struct elf_segment_map);
5284       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5285       map = bfd_alloc (obfd, amt);
5286       if (map == NULL)
5287         return FALSE;
5288
5289       /* Initialise the fields of the segment map.  Default to
5290          using the physical address of the segment in the input BFD.  */
5291       map->next          = NULL;
5292       map->p_type        = segment->p_type;
5293       map->p_flags       = segment->p_flags;
5294       map->p_flags_valid = 1;
5295       map->p_paddr       = segment->p_paddr;
5296       map->p_paddr_valid = 1;
5297
5298       /* Determine if this segment contains the ELF file header
5299          and if it contains the program headers themselves.  */
5300       map->includes_filehdr = (segment->p_offset == 0
5301                                && segment->p_filesz >= iehdr->e_ehsize);
5302
5303       map->includes_phdrs = 0;
5304
5305       if (! phdr_included || segment->p_type != PT_LOAD)
5306         {
5307           map->includes_phdrs =
5308             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5309              && (segment->p_offset + segment->p_filesz
5310                  >= ((bfd_vma) iehdr->e_phoff
5311                      + iehdr->e_phnum * iehdr->e_phentsize)));
5312
5313           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5314             phdr_included = TRUE;
5315         }
5316
5317       if (section_count == 0)
5318         {
5319           /* Special segments, such as the PT_PHDR segment, may contain
5320              no sections, but ordinary, loadable segments should contain
5321              something.  They are allowed by the ELF spec however, so only
5322              a warning is produced.  */
5323           if (segment->p_type == PT_LOAD)
5324             (*_bfd_error_handler)
5325               (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5326                ibfd);
5327
5328           map->count = 0;
5329           *pointer_to_map = map;
5330           pointer_to_map = &map->next;
5331
5332           continue;
5333         }
5334
5335       /* Now scan the sections in the input BFD again and attempt
5336          to add their corresponding output sections to the segment map.
5337          The problem here is how to handle an output section which has
5338          been moved (ie had its LMA changed).  There are four possibilities:
5339
5340          1. None of the sections have been moved.
5341             In this case we can continue to use the segment LMA from the
5342             input BFD.
5343
5344          2. All of the sections have been moved by the same amount.
5345             In this case we can change the segment's LMA to match the LMA
5346             of the first section.
5347
5348          3. Some of the sections have been moved, others have not.
5349             In this case those sections which have not been moved can be
5350             placed in the current segment which will have to have its size,
5351             and possibly its LMA changed, and a new segment or segments will
5352             have to be created to contain the other sections.
5353
5354          4. The sections have been moved, but not by the same amount.
5355             In this case we can change the segment's LMA to match the LMA
5356             of the first section and we will have to create a new segment
5357             or segments to contain the other sections.
5358
5359          In order to save time, we allocate an array to hold the section
5360          pointers that we are interested in.  As these sections get assigned
5361          to a segment, they are removed from this array.  */
5362
5363       /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5364          to work around this long long bug.  */
5365       sections = bfd_malloc2 (section_count, sizeof (asection *));
5366       if (sections == NULL)
5367         return FALSE;
5368
5369       /* Step One: Scan for segment vs section LMA conflicts.
5370          Also add the sections to the section array allocated above.
5371          Also add the sections to the current segment.  In the common
5372          case, where the sections have not been moved, this means that
5373          we have completely filled the segment, and there is nothing
5374          more to do.  */
5375       isec = 0;
5376       matching_lma = 0;
5377       suggested_lma = 0;
5378
5379       for (j = 0, section = ibfd->sections;
5380            section != NULL;
5381            section = section->next)
5382         {
5383           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5384             {
5385               output_section = section->output_section;
5386
5387               sections[j ++] = section;
5388
5389               /* The Solaris native linker always sets p_paddr to 0.
5390                  We try to catch that case here, and set it to the
5391                  correct value.  Note - some backends require that
5392                  p_paddr be left as zero.  */
5393               if (segment->p_paddr == 0
5394                   && segment->p_vaddr != 0
5395                   && (! bed->want_p_paddr_set_to_zero)
5396                   && isec == 0
5397                   && output_section->lma != 0
5398                   && (output_section->vma == (segment->p_vaddr
5399                                               + (map->includes_filehdr
5400                                                  ? iehdr->e_ehsize
5401                                                  : 0)
5402                                               + (map->includes_phdrs
5403                                                  ? (iehdr->e_phnum
5404                                                     * iehdr->e_phentsize)
5405                                                  : 0))))
5406                 map->p_paddr = segment->p_vaddr;
5407
5408               /* Match up the physical address of the segment with the
5409                  LMA address of the output section.  */
5410               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5411                   || IS_COREFILE_NOTE (segment, section)
5412                   || (bed->want_p_paddr_set_to_zero &&
5413                       IS_CONTAINED_BY_VMA (output_section, segment))
5414                 )
5415                 {
5416                   if (matching_lma == 0)
5417                     matching_lma = output_section->lma;
5418
5419                   /* We assume that if the section fits within the segment
5420                      then it does not overlap any other section within that
5421                      segment.  */
5422                   map->sections[isec ++] = output_section;
5423                 }
5424               else if (suggested_lma == 0)
5425                 suggested_lma = output_section->lma;
5426             }
5427         }
5428
5429       BFD_ASSERT (j == section_count);
5430
5431       /* Step Two: Adjust the physical address of the current segment,
5432          if necessary.  */
5433       if (isec == section_count)
5434         {
5435           /* All of the sections fitted within the segment as currently
5436              specified.  This is the default case.  Add the segment to
5437              the list of built segments and carry on to process the next
5438              program header in the input BFD.  */
5439           map->count = section_count;
5440           *pointer_to_map = map;
5441           pointer_to_map = &map->next;
5442
5443           free (sections);
5444           continue;
5445         }
5446       else
5447         {
5448           if (matching_lma != 0)
5449             {
5450               /* At least one section fits inside the current segment.
5451                  Keep it, but modify its physical address to match the
5452                  LMA of the first section that fitted.  */
5453               map->p_paddr = matching_lma;
5454             }
5455           else
5456             {
5457               /* None of the sections fitted inside the current segment.
5458                  Change the current segment's physical address to match
5459                  the LMA of the first section.  */
5460               map->p_paddr = suggested_lma;
5461             }
5462
5463           /* Offset the segment physical address from the lma
5464              to allow for space taken up by elf headers.  */
5465           if (map->includes_filehdr)
5466             map->p_paddr -= iehdr->e_ehsize;
5467
5468           if (map->includes_phdrs)
5469             {
5470               map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5471
5472               /* iehdr->e_phnum is just an estimate of the number
5473                  of program headers that we will need.  Make a note
5474                  here of the number we used and the segment we chose
5475                  to hold these headers, so that we can adjust the
5476                  offset when we know the correct value.  */
5477               phdr_adjust_num = iehdr->e_phnum;
5478               phdr_adjust_seg = map;
5479             }
5480         }
5481
5482       /* Step Three: Loop over the sections again, this time assigning
5483          those that fit to the current segment and removing them from the
5484          sections array; but making sure not to leave large gaps.  Once all
5485          possible sections have been assigned to the current segment it is
5486          added to the list of built segments and if sections still remain
5487          to be assigned, a new segment is constructed before repeating
5488          the loop.  */
5489       isec = 0;
5490       do
5491         {
5492           map->count = 0;
5493           suggested_lma = 0;
5494
5495           /* Fill the current segment with sections that fit.  */
5496           for (j = 0; j < section_count; j++)
5497             {
5498               section = sections[j];
5499
5500               if (section == NULL)
5501                 continue;
5502
5503               output_section = section->output_section;
5504
5505               BFD_ASSERT (output_section != NULL);
5506
5507               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5508                   || IS_COREFILE_NOTE (segment, section))
5509                 {
5510                   if (map->count == 0)
5511                     {
5512                       /* If the first section in a segment does not start at
5513                          the beginning of the segment, then something is
5514                          wrong.  */
5515                       if (output_section->lma !=
5516                           (map->p_paddr
5517                            + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5518                            + (map->includes_phdrs
5519                               ? iehdr->e_phnum * iehdr->e_phentsize
5520                               : 0)))
5521                         abort ();
5522                     }
5523                   else
5524                     {
5525                       asection * prev_sec;
5526
5527                       prev_sec = map->sections[map->count - 1];
5528
5529                       /* If the gap between the end of the previous section
5530                          and the start of this section is more than
5531                          maxpagesize then we need to start a new segment.  */
5532                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5533                                       maxpagesize)
5534                            < BFD_ALIGN (output_section->lma, maxpagesize))
5535                           || ((prev_sec->lma + prev_sec->size)
5536                               > output_section->lma))
5537                         {
5538                           if (suggested_lma == 0)
5539                             suggested_lma = output_section->lma;
5540
5541                           continue;
5542                         }
5543                     }
5544
5545                   map->sections[map->count++] = output_section;
5546                   ++isec;
5547                   sections[j] = NULL;
5548                   section->segment_mark = TRUE;
5549                 }
5550               else if (suggested_lma == 0)
5551                 suggested_lma = output_section->lma;
5552             }
5553
5554           BFD_ASSERT (map->count > 0);
5555
5556           /* Add the current segment to the list of built segments.  */
5557           *pointer_to_map = map;
5558           pointer_to_map = &map->next;
5559
5560           if (isec < section_count)
5561             {
5562               /* We still have not allocated all of the sections to
5563                  segments.  Create a new segment here, initialise it
5564                  and carry on looping.  */
5565               amt = sizeof (struct elf_segment_map);
5566               amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5567               map = bfd_alloc (obfd, amt);
5568               if (map == NULL)
5569                 {
5570                   free (sections);
5571                   return FALSE;
5572                 }
5573
5574               /* Initialise the fields of the segment map.  Set the physical
5575                  physical address to the LMA of the first section that has
5576                  not yet been assigned.  */
5577               map->next             = NULL;
5578               map->p_type           = segment->p_type;
5579               map->p_flags          = segment->p_flags;
5580               map->p_flags_valid    = 1;
5581               map->p_paddr          = suggested_lma;
5582               map->p_paddr_valid    = 1;
5583               map->includes_filehdr = 0;
5584               map->includes_phdrs   = 0;
5585             }
5586         }
5587       while (isec < section_count);
5588
5589       free (sections);
5590     }
5591
5592   /* The Solaris linker creates program headers in which all the
5593      p_paddr fields are zero.  When we try to objcopy or strip such a
5594      file, we get confused.  Check for this case, and if we find it
5595      reset the p_paddr_valid fields.  */
5596   for (map = map_first; map != NULL; map = map->next)
5597     if (map->p_paddr != 0)
5598       break;
5599   if (map == NULL)
5600     for (map = map_first; map != NULL; map = map->next)
5601       map->p_paddr_valid = 0;
5602
5603   elf_tdata (obfd)->segment_map = map_first;
5604
5605   /* If we had to estimate the number of program headers that were
5606      going to be needed, then check our estimate now and adjust
5607      the offset if necessary.  */
5608   if (phdr_adjust_seg != NULL)
5609     {
5610       unsigned int count;
5611
5612       for (count = 0, map = map_first; map != NULL; map = map->next)
5613         count++;
5614
5615       if (count > phdr_adjust_num)
5616         phdr_adjust_seg->p_paddr
5617           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5618     }
5619
5620 #undef SEGMENT_END
5621 #undef SECTION_SIZE
5622 #undef IS_CONTAINED_BY_VMA
5623 #undef IS_CONTAINED_BY_LMA
5624 #undef IS_COREFILE_NOTE
5625 #undef IS_SOLARIS_PT_INTERP
5626 #undef INCLUDE_SECTION_IN_SEGMENT
5627 #undef SEGMENT_AFTER_SEGMENT
5628 #undef SEGMENT_OVERLAPS
5629   return TRUE;
5630 }
5631
5632 /* Initialize private output section information from input section.  */
5633
5634 bfd_boolean
5635 _bfd_elf_init_private_section_data (bfd *ibfd,
5636                                     asection *isec,
5637                                     bfd *obfd,
5638                                     asection *osec,
5639                                     struct bfd_link_info *link_info)
5640
5641 {
5642   Elf_Internal_Shdr *ihdr, *ohdr;
5643   bfd_boolean need_group = link_info == NULL || link_info->relocatable;
5644
5645   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5646       || obfd->xvec->flavour != bfd_target_elf_flavour)
5647     return TRUE;
5648
5649   /* FIXME: What if the output ELF section type has been set to
5650      something different?  */
5651   if (elf_section_type (osec) == SHT_NULL)
5652     elf_section_type (osec) = elf_section_type (isec);
5653
5654   /* Set things up for objcopy and relocatable link.  The output
5655      SHT_GROUP section will have its elf_next_in_group pointing back
5656      to the input group members.  Ignore linker created group section.
5657      See elfNN_ia64_object_p in elfxx-ia64.c.  */
5658
5659   if (need_group)
5660     {
5661       if (elf_sec_group (isec) == NULL
5662           || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
5663         {
5664           if (elf_section_flags (isec) & SHF_GROUP)
5665             elf_section_flags (osec) |= SHF_GROUP;
5666           elf_next_in_group (osec) = elf_next_in_group (isec);
5667           elf_group_name (osec) = elf_group_name (isec);
5668         }
5669     }
5670
5671   ihdr = &elf_section_data (isec)->this_hdr;
5672
5673   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
5674      don't use the output section of the linked-to section since it
5675      may be NULL at this point.  */
5676   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
5677     {
5678       ohdr = &elf_section_data (osec)->this_hdr;
5679       ohdr->sh_flags |= SHF_LINK_ORDER;
5680       elf_linked_to_section (osec) = elf_linked_to_section (isec);
5681     }
5682
5683   osec->use_rela_p = isec->use_rela_p;
5684
5685   return TRUE;
5686 }
5687
5688 /* Copy private section information.  This copies over the entsize
5689    field, and sometimes the info field.  */
5690
5691 bfd_boolean
5692 _bfd_elf_copy_private_section_data (bfd *ibfd,
5693                                     asection *isec,
5694                                     bfd *obfd,
5695                                     asection *osec)
5696 {
5697   Elf_Internal_Shdr *ihdr, *ohdr;
5698
5699   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5700       || obfd->xvec->flavour != bfd_target_elf_flavour)
5701     return TRUE;
5702
5703   ihdr = &elf_section_data (isec)->this_hdr;
5704   ohdr = &elf_section_data (osec)->this_hdr;
5705
5706   ohdr->sh_entsize = ihdr->sh_entsize;
5707
5708   if (ihdr->sh_type == SHT_SYMTAB
5709       || ihdr->sh_type == SHT_DYNSYM
5710       || ihdr->sh_type == SHT_GNU_verneed
5711       || ihdr->sh_type == SHT_GNU_verdef)
5712     ohdr->sh_info = ihdr->sh_info;
5713
5714   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
5715                                              NULL);
5716 }
5717
5718 /* Copy private header information.  */
5719
5720 bfd_boolean
5721 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
5722 {
5723   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5724       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5725     return TRUE;
5726
5727   /* Copy over private BFD data if it has not already been copied.
5728      This must be done here, rather than in the copy_private_bfd_data
5729      entry point, because the latter is called after the section
5730      contents have been set, which means that the program headers have
5731      already been worked out.  */
5732   if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5733     {
5734       if (! copy_private_bfd_data (ibfd, obfd))
5735         return FALSE;
5736     }
5737
5738   return TRUE;
5739 }
5740
5741 /* Copy private symbol information.  If this symbol is in a section
5742    which we did not map into a BFD section, try to map the section
5743    index correctly.  We use special macro definitions for the mapped
5744    section indices; these definitions are interpreted by the
5745    swap_out_syms function.  */
5746
5747 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5748 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5749 #define MAP_STRTAB    (SHN_HIOS + 3)
5750 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
5751 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5752
5753 bfd_boolean
5754 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
5755                                    asymbol *isymarg,
5756                                    bfd *obfd,
5757                                    asymbol *osymarg)
5758 {
5759   elf_symbol_type *isym, *osym;
5760
5761   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5762       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5763     return TRUE;
5764
5765   isym = elf_symbol_from (ibfd, isymarg);
5766   osym = elf_symbol_from (obfd, osymarg);
5767
5768   if (isym != NULL
5769       && osym != NULL
5770       && bfd_is_abs_section (isym->symbol.section))
5771     {
5772       unsigned int shndx;
5773
5774       shndx = isym->internal_elf_sym.st_shndx;
5775       if (shndx == elf_onesymtab (ibfd))
5776         shndx = MAP_ONESYMTAB;
5777       else if (shndx == elf_dynsymtab (ibfd))
5778         shndx = MAP_DYNSYMTAB;
5779       else if (shndx == elf_tdata (ibfd)->strtab_section)
5780         shndx = MAP_STRTAB;
5781       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5782         shndx = MAP_SHSTRTAB;
5783       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5784         shndx = MAP_SYM_SHNDX;
5785       osym->internal_elf_sym.st_shndx = shndx;
5786     }
5787
5788   return TRUE;
5789 }
5790
5791 /* Swap out the symbols.  */
5792
5793 static bfd_boolean
5794 swap_out_syms (bfd *abfd,
5795                struct bfd_strtab_hash **sttp,
5796                int relocatable_p)
5797 {
5798   const struct elf_backend_data *bed;
5799   int symcount;
5800   asymbol **syms;
5801   struct bfd_strtab_hash *stt;
5802   Elf_Internal_Shdr *symtab_hdr;
5803   Elf_Internal_Shdr *symtab_shndx_hdr;
5804   Elf_Internal_Shdr *symstrtab_hdr;
5805   bfd_byte *outbound_syms;
5806   bfd_byte *outbound_shndx;
5807   int idx;
5808   bfd_size_type amt;
5809   bfd_boolean name_local_sections;
5810
5811   if (!elf_map_symbols (abfd))
5812     return FALSE;
5813
5814   /* Dump out the symtabs.  */
5815   stt = _bfd_elf_stringtab_init ();
5816   if (stt == NULL)
5817     return FALSE;
5818
5819   bed = get_elf_backend_data (abfd);
5820   symcount = bfd_get_symcount (abfd);
5821   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5822   symtab_hdr->sh_type = SHT_SYMTAB;
5823   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5824   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5825   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5826   symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
5827
5828   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5829   symstrtab_hdr->sh_type = SHT_STRTAB;
5830
5831   outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
5832   if (outbound_syms == NULL)
5833     {
5834       _bfd_stringtab_free (stt);
5835       return FALSE;
5836     }
5837   symtab_hdr->contents = outbound_syms;
5838
5839   outbound_shndx = NULL;
5840   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5841   if (symtab_shndx_hdr->sh_name != 0)
5842     {
5843       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5844       outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
5845                                     sizeof (Elf_External_Sym_Shndx));
5846       if (outbound_shndx == NULL)
5847         {
5848           _bfd_stringtab_free (stt);
5849           return FALSE;
5850         }
5851
5852       symtab_shndx_hdr->contents = outbound_shndx;
5853       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5854       symtab_shndx_hdr->sh_size = amt;
5855       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5856       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5857     }
5858
5859   /* Now generate the data (for "contents").  */
5860   {
5861     /* Fill in zeroth symbol and swap it out.  */
5862     Elf_Internal_Sym sym;
5863     sym.st_name = 0;
5864     sym.st_value = 0;
5865     sym.st_size = 0;
5866     sym.st_info = 0;
5867     sym.st_other = 0;
5868     sym.st_shndx = SHN_UNDEF;
5869     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5870     outbound_syms += bed->s->sizeof_sym;
5871     if (outbound_shndx != NULL)
5872       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5873   }
5874
5875   name_local_sections
5876     = (bed->elf_backend_name_local_section_symbols
5877        && bed->elf_backend_name_local_section_symbols (abfd));
5878
5879   syms = bfd_get_outsymbols (abfd);
5880   for (idx = 0; idx < symcount; idx++)
5881     {
5882       Elf_Internal_Sym sym;
5883       bfd_vma value = syms[idx]->value;
5884       elf_symbol_type *type_ptr;
5885       flagword flags = syms[idx]->flags;
5886       int type;
5887
5888       if (!name_local_sections
5889           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5890         {
5891           /* Local section symbols have no name.  */
5892           sym.st_name = 0;
5893         }
5894       else
5895         {
5896           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5897                                                             syms[idx]->name,
5898                                                             TRUE, FALSE);
5899           if (sym.st_name == (unsigned long) -1)
5900             {
5901               _bfd_stringtab_free (stt);
5902               return FALSE;
5903             }
5904         }
5905
5906       type_ptr = elf_symbol_from (abfd, syms[idx]);
5907
5908       if ((flags & BSF_SECTION_SYM) == 0
5909           && bfd_is_com_section (syms[idx]->section))
5910         {
5911           /* ELF common symbols put the alignment into the `value' field,
5912              and the size into the `size' field.  This is backwards from
5913              how BFD handles it, so reverse it here.  */
5914           sym.st_size = value;
5915           if (type_ptr == NULL
5916               || type_ptr->internal_elf_sym.st_value == 0)
5917             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5918           else
5919             sym.st_value = type_ptr->internal_elf_sym.st_value;
5920           sym.st_shndx = _bfd_elf_section_from_bfd_section
5921             (abfd, syms[idx]->section);
5922         }
5923       else
5924         {
5925           asection *sec = syms[idx]->section;
5926           int shndx;
5927
5928           if (sec->output_section)
5929             {
5930               value += sec->output_offset;
5931               sec = sec->output_section;
5932             }
5933
5934           /* Don't add in the section vma for relocatable output.  */
5935           if (! relocatable_p)
5936             value += sec->vma;
5937           sym.st_value = value;
5938           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5939
5940           if (bfd_is_abs_section (sec)
5941               && type_ptr != NULL
5942               && type_ptr->internal_elf_sym.st_shndx != 0)
5943             {
5944               /* This symbol is in a real ELF section which we did
5945                  not create as a BFD section.  Undo the mapping done
5946                  by copy_private_symbol_data.  */
5947               shndx = type_ptr->internal_elf_sym.st_shndx;
5948               switch (shndx)
5949                 {
5950                 case MAP_ONESYMTAB:
5951                   shndx = elf_onesymtab (abfd);
5952                   break;
5953                 case MAP_DYNSYMTAB:
5954                   shndx = elf_dynsymtab (abfd);
5955                   break;
5956                 case MAP_STRTAB:
5957                   shndx = elf_tdata (abfd)->strtab_section;
5958                   break;
5959                 case MAP_SHSTRTAB:
5960                   shndx = elf_tdata (abfd)->shstrtab_section;
5961                   break;
5962                 case MAP_SYM_SHNDX:
5963                   shndx = elf_tdata (abfd)->symtab_shndx_section;
5964                   break;
5965                 default:
5966                   break;
5967                 }
5968             }
5969           else
5970             {
5971               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5972
5973               if (shndx == -1)
5974                 {
5975                   asection *sec2;
5976
5977                   /* Writing this would be a hell of a lot easier if
5978                      we had some decent documentation on bfd, and
5979                      knew what to expect of the library, and what to
5980                      demand of applications.  For example, it
5981                      appears that `objcopy' might not set the
5982                      section of a symbol to be a section that is
5983                      actually in the output file.  */
5984                   sec2 = bfd_get_section_by_name (abfd, sec->name);
5985                   if (sec2 == NULL)
5986                     {
5987                       _bfd_error_handler (_("\
5988 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5989                                           syms[idx]->name ? syms[idx]->name : "<Local sym>",
5990                                           sec->name);
5991                       bfd_set_error (bfd_error_invalid_operation);
5992                       _bfd_stringtab_free (stt);
5993                       return FALSE;
5994                     }
5995
5996                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5997                   BFD_ASSERT (shndx != -1);
5998                 }
5999             }
6000
6001           sym.st_shndx = shndx;
6002         }
6003
6004       if ((flags & BSF_THREAD_LOCAL) != 0)
6005         type = STT_TLS;
6006       else if ((flags & BSF_FUNCTION) != 0)
6007         type = STT_FUNC;
6008       else if ((flags & BSF_OBJECT) != 0)
6009         type = STT_OBJECT;
6010       else
6011         type = STT_NOTYPE;
6012
6013       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6014         type = STT_TLS;
6015
6016       /* Processor-specific types.  */
6017       if (type_ptr != NULL
6018           && bed->elf_backend_get_symbol_type)
6019         type = ((*bed->elf_backend_get_symbol_type)
6020                 (&type_ptr->internal_elf_sym, type));
6021
6022       if (flags & BSF_SECTION_SYM)
6023         {
6024           if (flags & BSF_GLOBAL)
6025             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6026           else
6027             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6028         }
6029       else if (bfd_is_com_section (syms[idx]->section))
6030         sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6031       else if (bfd_is_und_section (syms[idx]->section))
6032         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6033                                     ? STB_WEAK
6034                                     : STB_GLOBAL),
6035                                    type);
6036       else if (flags & BSF_FILE)
6037         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6038       else
6039         {
6040           int bind = STB_LOCAL;
6041
6042           if (flags & BSF_LOCAL)
6043             bind = STB_LOCAL;
6044           else if (flags & BSF_WEAK)
6045             bind = STB_WEAK;
6046           else if (flags & BSF_GLOBAL)
6047             bind = STB_GLOBAL;
6048
6049           sym.st_info = ELF_ST_INFO (bind, type);
6050         }
6051
6052       if (type_ptr != NULL)
6053         sym.st_other = type_ptr->internal_elf_sym.st_other;
6054       else
6055         sym.st_other = 0;
6056
6057       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6058       outbound_syms += bed->s->sizeof_sym;
6059       if (outbound_shndx != NULL)
6060         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6061     }
6062
6063   *sttp = stt;
6064   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6065   symstrtab_hdr->sh_type = SHT_STRTAB;
6066
6067   symstrtab_hdr->sh_flags = 0;
6068   symstrtab_hdr->sh_addr = 0;
6069   symstrtab_hdr->sh_entsize = 0;
6070   symstrtab_hdr->sh_link = 0;
6071   symstrtab_hdr->sh_info = 0;
6072   symstrtab_hdr->sh_addralign = 1;
6073
6074   return TRUE;
6075 }
6076
6077 /* Return the number of bytes required to hold the symtab vector.
6078
6079    Note that we base it on the count plus 1, since we will null terminate
6080    the vector allocated based on this size.  However, the ELF symbol table
6081    always has a dummy entry as symbol #0, so it ends up even.  */
6082
6083 long
6084 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6085 {
6086   long symcount;
6087   long symtab_size;
6088   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6089
6090   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6091   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6092   if (symcount > 0)
6093     symtab_size -= sizeof (asymbol *);
6094
6095   return symtab_size;
6096 }
6097
6098 long
6099 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6100 {
6101   long symcount;
6102   long symtab_size;
6103   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6104
6105   if (elf_dynsymtab (abfd) == 0)
6106     {
6107       bfd_set_error (bfd_error_invalid_operation);
6108       return -1;
6109     }
6110
6111   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6112   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6113   if (symcount > 0)
6114     symtab_size -= sizeof (asymbol *);
6115
6116   return symtab_size;
6117 }
6118
6119 long
6120 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6121                                 sec_ptr asect)
6122 {
6123   return (asect->reloc_count + 1) * sizeof (arelent *);
6124 }
6125
6126 /* Canonicalize the relocs.  */
6127
6128 long
6129 _bfd_elf_canonicalize_reloc (bfd *abfd,
6130                              sec_ptr section,
6131                              arelent **relptr,
6132                              asymbol **symbols)
6133 {
6134   arelent *tblptr;
6135   unsigned int i;
6136   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6137
6138   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6139     return -1;
6140
6141   tblptr = section->relocation;
6142   for (i = 0; i < section->reloc_count; i++)
6143     *relptr++ = tblptr++;
6144
6145   *relptr = NULL;
6146
6147   return section->reloc_count;
6148 }
6149
6150 long
6151 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6152 {
6153   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6154   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6155
6156   if (symcount >= 0)
6157     bfd_get_symcount (abfd) = symcount;
6158   return symcount;
6159 }
6160
6161 long
6162 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6163                                       asymbol **allocation)
6164 {
6165   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6166   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6167
6168   if (symcount >= 0)
6169     bfd_get_dynamic_symcount (abfd) = symcount;
6170   return symcount;
6171 }
6172
6173 /* Return the size required for the dynamic reloc entries.  Any loadable
6174    section that was actually installed in the BFD, and has type SHT_REL
6175    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6176    dynamic reloc section.  */
6177
6178 long
6179 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6180 {
6181   long ret;
6182   asection *s;
6183
6184   if (elf_dynsymtab (abfd) == 0)
6185     {
6186       bfd_set_error (bfd_error_invalid_operation);
6187       return -1;
6188     }
6189
6190   ret = sizeof (arelent *);
6191   for (s = abfd->sections; s != NULL; s = s->next)
6192     if ((s->flags & SEC_LOAD) != 0
6193         && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6194         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6195             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6196       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6197               * sizeof (arelent *));
6198
6199   return ret;
6200 }
6201
6202 /* Canonicalize the dynamic relocation entries.  Note that we return the
6203    dynamic relocations as a single block, although they are actually
6204    associated with particular sections; the interface, which was
6205    designed for SunOS style shared libraries, expects that there is only
6206    one set of dynamic relocs.  Any loadable section that was actually
6207    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6208    dynamic symbol table, is considered to be a dynamic reloc section.  */
6209
6210 long
6211 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6212                                      arelent **storage,
6213                                      asymbol **syms)
6214 {
6215   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6216   asection *s;
6217   long ret;
6218
6219   if (elf_dynsymtab (abfd) == 0)
6220     {
6221       bfd_set_error (bfd_error_invalid_operation);
6222       return -1;
6223     }
6224
6225   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6226   ret = 0;
6227   for (s = abfd->sections; s != NULL; s = s->next)
6228     {
6229       if ((s->flags & SEC_LOAD) != 0
6230           && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6231           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6232               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6233         {
6234           arelent *p;
6235           long count, i;
6236
6237           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6238             return -1;
6239           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6240           p = s->relocation;
6241           for (i = 0; i < count; i++)
6242             *storage++ = p++;
6243           ret += count;
6244         }
6245     }
6246
6247   *storage = NULL;
6248
6249   return ret;
6250 }
6251 \f
6252 /* Read in the version information.  */
6253
6254 bfd_boolean
6255 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6256 {
6257   bfd_byte *contents = NULL;
6258   unsigned int freeidx = 0;
6259
6260   if (elf_dynverref (abfd) != 0)
6261     {
6262       Elf_Internal_Shdr *hdr;
6263       Elf_External_Verneed *everneed;
6264       Elf_Internal_Verneed *iverneed;
6265       unsigned int i;
6266       bfd_byte *contents_end;
6267
6268       hdr = &elf_tdata (abfd)->dynverref_hdr;
6269
6270       elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6271                                               sizeof (Elf_Internal_Verneed));
6272       if (elf_tdata (abfd)->verref == NULL)
6273         goto error_return;
6274
6275       elf_tdata (abfd)->cverrefs = hdr->sh_info;
6276
6277       contents = bfd_malloc (hdr->sh_size);
6278       if (contents == NULL)
6279         {
6280 error_return_verref:
6281           elf_tdata (abfd)->verref = NULL;
6282           elf_tdata (abfd)->cverrefs = 0;
6283           goto error_return;
6284         }
6285       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6286           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6287         goto error_return_verref;
6288
6289       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6290         goto error_return_verref;
6291
6292       BFD_ASSERT (sizeof (Elf_External_Verneed)
6293                   == sizeof (Elf_External_Vernaux));
6294       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6295       everneed = (Elf_External_Verneed *) contents;
6296       iverneed = elf_tdata (abfd)->verref;
6297       for (i = 0; i < hdr->sh_info; i++, iverneed++)
6298         {
6299           Elf_External_Vernaux *evernaux;
6300           Elf_Internal_Vernaux *ivernaux;
6301           unsigned int j;
6302
6303           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6304
6305           iverneed->vn_bfd = abfd;
6306
6307           iverneed->vn_filename =
6308             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6309                                              iverneed->vn_file);
6310           if (iverneed->vn_filename == NULL)
6311             goto error_return_verref;
6312
6313           if (iverneed->vn_cnt == 0)
6314             iverneed->vn_auxptr = NULL;
6315           else
6316             {
6317               iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6318                                                 sizeof (Elf_Internal_Vernaux));
6319               if (iverneed->vn_auxptr == NULL)
6320                 goto error_return_verref;
6321             }
6322
6323           if (iverneed->vn_aux
6324               > (size_t) (contents_end - (bfd_byte *) everneed))
6325             goto error_return_verref;
6326
6327           evernaux = ((Elf_External_Vernaux *)
6328                       ((bfd_byte *) everneed + iverneed->vn_aux));
6329           ivernaux = iverneed->vn_auxptr;
6330           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6331             {
6332               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6333
6334               ivernaux->vna_nodename =
6335                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6336                                                  ivernaux->vna_name);
6337               if (ivernaux->vna_nodename == NULL)
6338                 goto error_return_verref;
6339
6340               if (j + 1 < iverneed->vn_cnt)
6341                 ivernaux->vna_nextptr = ivernaux + 1;
6342               else
6343                 ivernaux->vna_nextptr = NULL;
6344
6345               if (ivernaux->vna_next
6346                   > (size_t) (contents_end - (bfd_byte *) evernaux))
6347                 goto error_return_verref;
6348
6349               evernaux = ((Elf_External_Vernaux *)
6350                           ((bfd_byte *) evernaux + ivernaux->vna_next));
6351
6352               if (ivernaux->vna_other > freeidx)
6353                 freeidx = ivernaux->vna_other;
6354             }
6355
6356           if (i + 1 < hdr->sh_info)
6357             iverneed->vn_nextref = iverneed + 1;
6358           else
6359             iverneed->vn_nextref = NULL;
6360
6361           if (iverneed->vn_next
6362               > (size_t) (contents_end - (bfd_byte *) everneed))
6363             goto error_return_verref;
6364
6365           everneed = ((Elf_External_Verneed *)
6366                       ((bfd_byte *) everneed + iverneed->vn_next));
6367         }
6368
6369       free (contents);
6370       contents = NULL;
6371     }
6372
6373   if (elf_dynverdef (abfd) != 0)
6374     {
6375       Elf_Internal_Shdr *hdr;
6376       Elf_External_Verdef *everdef;
6377       Elf_Internal_Verdef *iverdef;
6378       Elf_Internal_Verdef *iverdefarr;
6379       Elf_Internal_Verdef iverdefmem;
6380       unsigned int i;
6381       unsigned int maxidx;
6382       bfd_byte *contents_end_def, *contents_end_aux;
6383
6384       hdr = &elf_tdata (abfd)->dynverdef_hdr;
6385
6386       contents = bfd_malloc (hdr->sh_size);
6387       if (contents == NULL)
6388         goto error_return;
6389       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6390           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6391         goto error_return;
6392
6393       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6394         goto error_return;
6395
6396       BFD_ASSERT (sizeof (Elf_External_Verdef)
6397                   >= sizeof (Elf_External_Verdaux));
6398       contents_end_def = contents + hdr->sh_size
6399                          - sizeof (Elf_External_Verdef);
6400       contents_end_aux = contents + hdr->sh_size
6401                          - sizeof (Elf_External_Verdaux);
6402
6403       /* We know the number of entries in the section but not the maximum
6404          index.  Therefore we have to run through all entries and find
6405          the maximum.  */
6406       everdef = (Elf_External_Verdef *) contents;
6407       maxidx = 0;
6408       for (i = 0; i < hdr->sh_info; ++i)
6409         {
6410           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6411
6412           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6413             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6414
6415           if (iverdefmem.vd_next
6416               > (size_t) (contents_end_def - (bfd_byte *) everdef))
6417             goto error_return;
6418
6419           everdef = ((Elf_External_Verdef *)
6420                      ((bfd_byte *) everdef + iverdefmem.vd_next));
6421         }
6422
6423       if (default_imported_symver)
6424         {
6425           if (freeidx > maxidx)
6426             maxidx = ++freeidx;
6427           else
6428             freeidx = ++maxidx;
6429         }
6430       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6431                                               sizeof (Elf_Internal_Verdef));
6432       if (elf_tdata (abfd)->verdef == NULL)
6433         goto error_return;
6434
6435       elf_tdata (abfd)->cverdefs = maxidx;
6436
6437       everdef = (Elf_External_Verdef *) contents;
6438       iverdefarr = elf_tdata (abfd)->verdef;
6439       for (i = 0; i < hdr->sh_info; i++)
6440         {
6441           Elf_External_Verdaux *everdaux;
6442           Elf_Internal_Verdaux *iverdaux;
6443           unsigned int j;
6444
6445           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6446
6447           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6448             {
6449 error_return_verdef:
6450               elf_tdata (abfd)->verdef = NULL;
6451               elf_tdata (abfd)->cverdefs = 0;
6452               goto error_return;
6453             }
6454
6455           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6456           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6457
6458           iverdef->vd_bfd = abfd;
6459
6460           if (iverdef->vd_cnt == 0)
6461             iverdef->vd_auxptr = NULL;
6462           else
6463             {
6464               iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6465                                                sizeof (Elf_Internal_Verdaux));
6466               if (iverdef->vd_auxptr == NULL)
6467                 goto error_return_verdef;
6468             }
6469
6470           if (iverdef->vd_aux
6471               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6472             goto error_return_verdef;
6473
6474           everdaux = ((Elf_External_Verdaux *)
6475                       ((bfd_byte *) everdef + iverdef->vd_aux));
6476           iverdaux = iverdef->vd_auxptr;
6477           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6478             {
6479               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6480
6481               iverdaux->vda_nodename =
6482                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6483                                                  iverdaux->vda_name);
6484               if (iverdaux->vda_nodename == NULL)
6485                 goto error_return_verdef;
6486
6487               if (j + 1 < iverdef->vd_cnt)
6488                 iverdaux->vda_nextptr = iverdaux + 1;
6489               else
6490                 iverdaux->vda_nextptr = NULL;
6491
6492               if (iverdaux->vda_next
6493                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6494                 goto error_return_verdef;
6495
6496               everdaux = ((Elf_External_Verdaux *)
6497                           ((bfd_byte *) everdaux + iverdaux->vda_next));
6498             }
6499
6500           if (iverdef->vd_cnt)
6501             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6502
6503           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
6504             iverdef->vd_nextdef = iverdef + 1;
6505           else
6506             iverdef->vd_nextdef = NULL;
6507
6508           everdef = ((Elf_External_Verdef *)
6509                      ((bfd_byte *) everdef + iverdef->vd_next));
6510         }
6511
6512       free (contents);
6513       contents = NULL;
6514     }
6515   else if (default_imported_symver)
6516     {
6517       if (freeidx < 3)
6518         freeidx = 3;
6519       else
6520         freeidx++;
6521
6522       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6523                                               sizeof (Elf_Internal_Verdef));
6524       if (elf_tdata (abfd)->verdef == NULL)
6525         goto error_return;
6526
6527       elf_tdata (abfd)->cverdefs = freeidx;
6528     }
6529
6530   /* Create a default version based on the soname.  */
6531   if (default_imported_symver)
6532     {
6533       Elf_Internal_Verdef *iverdef;
6534       Elf_Internal_Verdaux *iverdaux;
6535
6536       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6537
6538       iverdef->vd_version = VER_DEF_CURRENT;
6539       iverdef->vd_flags = 0;
6540       iverdef->vd_ndx = freeidx;
6541       iverdef->vd_cnt = 1;
6542
6543       iverdef->vd_bfd = abfd;
6544
6545       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6546       if (iverdef->vd_nodename == NULL)
6547         goto error_return_verdef;
6548       iverdef->vd_nextdef = NULL;
6549       iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6550       if (iverdef->vd_auxptr == NULL)
6551         goto error_return_verdef;
6552
6553       iverdaux = iverdef->vd_auxptr;
6554       iverdaux->vda_nodename = iverdef->vd_nodename;
6555       iverdaux->vda_nextptr = NULL;
6556     }
6557
6558   return TRUE;
6559
6560  error_return:
6561   if (contents != NULL)
6562     free (contents);
6563   return FALSE;
6564 }
6565 \f
6566 asymbol *
6567 _bfd_elf_make_empty_symbol (bfd *abfd)
6568 {
6569   elf_symbol_type *newsym;
6570   bfd_size_type amt = sizeof (elf_symbol_type);
6571
6572   newsym = bfd_zalloc (abfd, amt);
6573   if (!newsym)
6574     return NULL;
6575   else
6576     {
6577       newsym->symbol.the_bfd = abfd;
6578       return &newsym->symbol;
6579     }
6580 }
6581
6582 void
6583 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6584                           asymbol *symbol,
6585                           symbol_info *ret)
6586 {
6587   bfd_symbol_info (symbol, ret);
6588 }
6589
6590 /* Return whether a symbol name implies a local symbol.  Most targets
6591    use this function for the is_local_label_name entry point, but some
6592    override it.  */
6593
6594 bfd_boolean
6595 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6596                               const char *name)
6597 {
6598   /* Normal local symbols start with ``.L''.  */
6599   if (name[0] == '.' && name[1] == 'L')
6600     return TRUE;
6601
6602   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6603      DWARF debugging symbols starting with ``..''.  */
6604   if (name[0] == '.' && name[1] == '.')
6605     return TRUE;
6606
6607   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6608      emitting DWARF debugging output.  I suspect this is actually a
6609      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6610      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6611      underscore to be emitted on some ELF targets).  For ease of use,
6612      we treat such symbols as local.  */
6613   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
6614     return TRUE;
6615
6616   return FALSE;
6617 }
6618
6619 alent *
6620 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6621                      asymbol *symbol ATTRIBUTE_UNUSED)
6622 {
6623   abort ();
6624   return NULL;
6625 }
6626
6627 bfd_boolean
6628 _bfd_elf_set_arch_mach (bfd *abfd,
6629                         enum bfd_architecture arch,
6630                         unsigned long machine)
6631 {
6632   /* If this isn't the right architecture for this backend, and this
6633      isn't the generic backend, fail.  */
6634   if (arch != get_elf_backend_data (abfd)->arch
6635       && arch != bfd_arch_unknown
6636       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
6637     return FALSE;
6638
6639   return bfd_default_set_arch_mach (abfd, arch, machine);
6640 }
6641
6642 /* Find the function to a particular section and offset,
6643    for error reporting.  */
6644
6645 static bfd_boolean
6646 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6647                    asection *section,
6648                    asymbol **symbols,
6649                    bfd_vma offset,
6650                    const char **filename_ptr,
6651                    const char **functionname_ptr)
6652 {
6653   const char *filename;
6654   asymbol *func, *file;
6655   bfd_vma low_func;
6656   asymbol **p;
6657   /* ??? Given multiple file symbols, it is impossible to reliably
6658      choose the right file name for global symbols.  File symbols are
6659      local symbols, and thus all file symbols must sort before any
6660      global symbols.  The ELF spec may be interpreted to say that a
6661      file symbol must sort before other local symbols, but currently
6662      ld -r doesn't do this.  So, for ld -r output, it is possible to
6663      make a better choice of file name for local symbols by ignoring
6664      file symbols appearing after a given local symbol.  */
6665   enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
6666
6667   filename = NULL;
6668   func = NULL;
6669   file = NULL;
6670   low_func = 0;
6671   state = nothing_seen;
6672
6673   for (p = symbols; *p != NULL; p++)
6674     {
6675       elf_symbol_type *q;
6676
6677       q = (elf_symbol_type *) *p;
6678
6679       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6680         {
6681         default:
6682           break;
6683         case STT_FILE:
6684           file = &q->symbol;
6685           if (state == symbol_seen)
6686             state = file_after_symbol_seen;
6687           continue;
6688         case STT_SECTION:
6689           continue;
6690         case STT_NOTYPE:
6691         case STT_FUNC:
6692           if (bfd_get_section (&q->symbol) == section
6693               && q->symbol.value >= low_func
6694               && q->symbol.value <= offset)
6695             {
6696               func = (asymbol *) q;
6697               low_func = q->symbol.value;
6698               if (file == NULL)
6699                 filename = NULL;
6700               else if (ELF_ST_BIND (q->internal_elf_sym.st_info) != STB_LOCAL
6701                        && state == file_after_symbol_seen)
6702                 filename = NULL;
6703               else
6704                 filename = bfd_asymbol_name (file);
6705             }
6706           break;
6707         }
6708       if (state == nothing_seen)
6709         state = symbol_seen;
6710     }
6711
6712   if (func == NULL)
6713     return FALSE;
6714
6715   if (filename_ptr)
6716     *filename_ptr = filename;
6717   if (functionname_ptr)
6718     *functionname_ptr = bfd_asymbol_name (func);
6719
6720   return TRUE;
6721 }
6722
6723 /* Find the nearest line to a particular section and offset,
6724    for error reporting.  */
6725
6726 bfd_boolean
6727 _bfd_elf_find_nearest_line (bfd *abfd,
6728                             asection *section,
6729                             asymbol **symbols,
6730                             bfd_vma offset,
6731                             const char **filename_ptr,
6732                             const char **functionname_ptr,
6733                             unsigned int *line_ptr)
6734 {
6735   bfd_boolean found;
6736
6737   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6738                                      filename_ptr, functionname_ptr,
6739                                      line_ptr))
6740     {
6741       if (!*functionname_ptr)
6742         elf_find_function (abfd, section, symbols, offset,
6743                            *filename_ptr ? NULL : filename_ptr,
6744                            functionname_ptr);
6745
6746       return TRUE;
6747     }
6748
6749   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6750                                      filename_ptr, functionname_ptr,
6751                                      line_ptr, 0,
6752                                      &elf_tdata (abfd)->dwarf2_find_line_info))
6753     {
6754       if (!*functionname_ptr)
6755         elf_find_function (abfd, section, symbols, offset,
6756                            *filename_ptr ? NULL : filename_ptr,
6757                            functionname_ptr);
6758
6759       return TRUE;
6760     }
6761
6762   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6763                                              &found, filename_ptr,
6764                                              functionname_ptr, line_ptr,
6765                                              &elf_tdata (abfd)->line_info))
6766     return FALSE;
6767   if (found && (*functionname_ptr || *line_ptr))
6768     return TRUE;
6769
6770   if (symbols == NULL)
6771     return FALSE;
6772
6773   if (! elf_find_function (abfd, section, symbols, offset,
6774                            filename_ptr, functionname_ptr))
6775     return FALSE;
6776
6777   *line_ptr = 0;
6778   return TRUE;
6779 }
6780
6781 /* Find the line for a symbol.  */
6782
6783 bfd_boolean
6784 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
6785                     const char **filename_ptr, unsigned int *line_ptr)
6786 {
6787   return _bfd_dwarf2_find_line (abfd, symbols, symbol,
6788                                 filename_ptr, line_ptr, 0,
6789                                 &elf_tdata (abfd)->dwarf2_find_line_info);
6790 }
6791
6792 /* After a call to bfd_find_nearest_line, successive calls to
6793    bfd_find_inliner_info can be used to get source information about
6794    each level of function inlining that terminated at the address
6795    passed to bfd_find_nearest_line.  Currently this is only supported
6796    for DWARF2 with appropriate DWARF3 extensions. */
6797
6798 bfd_boolean
6799 _bfd_elf_find_inliner_info (bfd *abfd,
6800                             const char **filename_ptr,
6801                             const char **functionname_ptr,
6802                             unsigned int *line_ptr)
6803 {
6804   bfd_boolean found;
6805   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
6806                                          functionname_ptr, line_ptr,
6807                                          & elf_tdata (abfd)->dwarf2_find_line_info);
6808   return found;
6809 }
6810
6811 int
6812 _bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
6813 {
6814   int ret;
6815
6816   ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6817   if (! reloc)
6818     ret += get_program_header_size (abfd);
6819   return ret;
6820 }
6821
6822 bfd_boolean
6823 _bfd_elf_set_section_contents (bfd *abfd,
6824                                sec_ptr section,
6825                                const void *location,
6826                                file_ptr offset,
6827                                bfd_size_type count)
6828 {
6829   Elf_Internal_Shdr *hdr;
6830   bfd_signed_vma pos;
6831
6832   if (! abfd->output_has_begun
6833       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6834     return FALSE;
6835
6836   hdr = &elf_section_data (section)->this_hdr;
6837   pos = hdr->sh_offset + offset;
6838   if (bfd_seek (abfd, pos, SEEK_SET) != 0
6839       || bfd_bwrite (location, count, abfd) != count)
6840     return FALSE;
6841
6842   return TRUE;
6843 }
6844
6845 void
6846 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
6847                            arelent *cache_ptr ATTRIBUTE_UNUSED,
6848                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
6849 {
6850   abort ();
6851 }
6852
6853 /* Try to convert a non-ELF reloc into an ELF one.  */
6854
6855 bfd_boolean
6856 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
6857 {
6858   /* Check whether we really have an ELF howto.  */
6859
6860   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6861     {
6862       bfd_reloc_code_real_type code;
6863       reloc_howto_type *howto;
6864
6865       /* Alien reloc: Try to determine its type to replace it with an
6866          equivalent ELF reloc.  */
6867
6868       if (areloc->howto->pc_relative)
6869         {
6870           switch (areloc->howto->bitsize)
6871             {
6872             case 8:
6873               code = BFD_RELOC_8_PCREL;
6874               break;
6875             case 12:
6876               code = BFD_RELOC_12_PCREL;
6877               break;
6878             case 16:
6879               code = BFD_RELOC_16_PCREL;
6880               break;
6881             case 24:
6882               code = BFD_RELOC_24_PCREL;
6883               break;
6884             case 32:
6885               code = BFD_RELOC_32_PCREL;
6886               break;
6887             case 64:
6888               code = BFD_RELOC_64_PCREL;
6889               break;
6890             default:
6891               goto fail;
6892             }
6893
6894           howto = bfd_reloc_type_lookup (abfd, code);
6895
6896           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6897             {
6898               if (howto->pcrel_offset)
6899                 areloc->addend += areloc->address;
6900               else
6901                 areloc->addend -= areloc->address; /* addend is unsigned!! */
6902             }
6903         }
6904       else
6905         {
6906           switch (areloc->howto->bitsize)
6907             {
6908             case 8:
6909               code = BFD_RELOC_8;
6910               break;
6911             case 14:
6912               code = BFD_RELOC_14;
6913               break;
6914             case 16:
6915               code = BFD_RELOC_16;
6916               break;
6917             case 26:
6918               code = BFD_RELOC_26;
6919               break;
6920             case 32:
6921               code = BFD_RELOC_32;
6922               break;
6923             case 64:
6924               code = BFD_RELOC_64;
6925               break;
6926             default:
6927               goto fail;
6928             }
6929
6930           howto = bfd_reloc_type_lookup (abfd, code);
6931         }
6932
6933       if (howto)
6934         areloc->howto = howto;
6935       else
6936         goto fail;
6937     }
6938
6939   return TRUE;
6940
6941  fail:
6942   (*_bfd_error_handler)
6943     (_("%B: unsupported relocation type %s"),
6944      abfd, areloc->howto->name);
6945   bfd_set_error (bfd_error_bad_value);
6946   return FALSE;
6947 }
6948
6949 bfd_boolean
6950 _bfd_elf_close_and_cleanup (bfd *abfd)
6951 {
6952   if (bfd_get_format (abfd) == bfd_object)
6953     {
6954       if (elf_shstrtab (abfd) != NULL)
6955         _bfd_elf_strtab_free (elf_shstrtab (abfd));
6956       _bfd_dwarf2_cleanup_debug_info (abfd);
6957     }
6958
6959   return _bfd_generic_close_and_cleanup (abfd);
6960 }
6961
6962 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6963    in the relocation's offset.  Thus we cannot allow any sort of sanity
6964    range-checking to interfere.  There is nothing else to do in processing
6965    this reloc.  */
6966
6967 bfd_reloc_status_type
6968 _bfd_elf_rel_vtable_reloc_fn
6969   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
6970    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
6971    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
6972    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
6973 {
6974   return bfd_reloc_ok;
6975 }
6976 \f
6977 /* Elf core file support.  Much of this only works on native
6978    toolchains, since we rely on knowing the
6979    machine-dependent procfs structure in order to pick
6980    out details about the corefile.  */
6981
6982 #ifdef HAVE_SYS_PROCFS_H
6983 # include <sys/procfs.h>
6984 #endif
6985
6986 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
6987
6988 static int
6989 elfcore_make_pid (bfd *abfd)
6990 {
6991   return ((elf_tdata (abfd)->core_lwpid << 16)
6992           + (elf_tdata (abfd)->core_pid));
6993 }
6994
6995 /* If there isn't a section called NAME, make one, using
6996    data from SECT.  Note, this function will generate a
6997    reference to NAME, so you shouldn't deallocate or
6998    overwrite it.  */
6999
7000 static bfd_boolean
7001 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7002 {
7003   asection *sect2;
7004
7005   if (bfd_get_section_by_name (abfd, name) != NULL)
7006     return TRUE;
7007
7008   sect2 = bfd_make_section (abfd, name);
7009   if (sect2 == NULL)
7010     return FALSE;
7011
7012   sect2->size = sect->size;
7013   sect2->filepos = sect->filepos;
7014   sect2->flags = sect->flags;
7015   sect2->alignment_power = sect->alignment_power;
7016   return TRUE;
7017 }
7018
7019 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
7020    actually creates up to two pseudosections:
7021    - For the single-threaded case, a section named NAME, unless
7022      such a section already exists.
7023    - For the multi-threaded case, a section named "NAME/PID", where
7024      PID is elfcore_make_pid (abfd).
7025    Both pseudosections have identical contents. */
7026 bfd_boolean
7027 _bfd_elfcore_make_pseudosection (bfd *abfd,
7028                                  char *name,
7029                                  size_t size,
7030                                  ufile_ptr filepos)
7031 {
7032   char buf[100];
7033   char *threaded_name;
7034   size_t len;
7035   asection *sect;
7036
7037   /* Build the section name.  */
7038
7039   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7040   len = strlen (buf) + 1;
7041   threaded_name = bfd_alloc (abfd, len);
7042   if (threaded_name == NULL)
7043     return FALSE;
7044   memcpy (threaded_name, buf, len);
7045
7046   sect = bfd_make_section_anyway (abfd, threaded_name);
7047   if (sect == NULL)
7048     return FALSE;
7049   sect->size = size;
7050   sect->filepos = filepos;
7051   sect->flags = SEC_HAS_CONTENTS;
7052   sect->alignment_power = 2;
7053
7054   return elfcore_maybe_make_sect (abfd, name, sect);
7055 }
7056
7057 /* prstatus_t exists on:
7058      solaris 2.5+
7059      linux 2.[01] + glibc
7060      unixware 4.2
7061 */
7062
7063 #if defined (HAVE_PRSTATUS_T)
7064
7065 static bfd_boolean
7066 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7067 {
7068   size_t size;
7069   int offset;
7070
7071   if (note->descsz == sizeof (prstatus_t))
7072     {
7073       prstatus_t prstat;
7074
7075       size = sizeof (prstat.pr_reg);
7076       offset   = offsetof (prstatus_t, pr_reg);
7077       memcpy (&prstat, note->descdata, sizeof (prstat));
7078
7079       /* Do not overwrite the core signal if it
7080          has already been set by another thread.  */
7081       if (elf_tdata (abfd)->core_signal == 0)
7082         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7083       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7084
7085       /* pr_who exists on:
7086          solaris 2.5+
7087          unixware 4.2
7088          pr_who doesn't exist on:
7089          linux 2.[01]
7090          */
7091 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7092       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7093 #endif
7094     }
7095 #if defined (HAVE_PRSTATUS32_T)
7096   else if (note->descsz == sizeof (prstatus32_t))
7097     {
7098       /* 64-bit host, 32-bit corefile */
7099       prstatus32_t prstat;
7100
7101       size = sizeof (prstat.pr_reg);
7102       offset   = offsetof (prstatus32_t, pr_reg);
7103       memcpy (&prstat, note->descdata, sizeof (prstat));
7104
7105       /* Do not overwrite the core signal if it
7106          has already been set by another thread.  */
7107       if (elf_tdata (abfd)->core_signal == 0)
7108         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7109       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7110
7111       /* pr_who exists on:
7112          solaris 2.5+
7113          unixware 4.2
7114          pr_who doesn't exist on:
7115          linux 2.[01]
7116          */
7117 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7118       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7119 #endif
7120     }
7121 #endif /* HAVE_PRSTATUS32_T */
7122   else
7123     {
7124       /* Fail - we don't know how to handle any other
7125          note size (ie. data object type).  */
7126       return TRUE;
7127     }
7128
7129   /* Make a ".reg/999" section and a ".reg" section.  */
7130   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7131                                           size, note->descpos + offset);
7132 }
7133 #endif /* defined (HAVE_PRSTATUS_T) */
7134
7135 /* Create a pseudosection containing the exact contents of NOTE.  */
7136 static bfd_boolean
7137 elfcore_make_note_pseudosection (bfd *abfd,
7138                                  char *name,
7139                                  Elf_Internal_Note *note)
7140 {
7141   return _bfd_elfcore_make_pseudosection (abfd, name,
7142                                           note->descsz, note->descpos);
7143 }
7144
7145 /* There isn't a consistent prfpregset_t across platforms,
7146    but it doesn't matter, because we don't have to pick this
7147    data structure apart.  */
7148
7149 static bfd_boolean
7150 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7151 {
7152   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7153 }
7154
7155 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7156    type of 5 (NT_PRXFPREG).  Just include the whole note's contents
7157    literally.  */
7158
7159 static bfd_boolean
7160 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7161 {
7162   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7163 }
7164
7165 #if defined (HAVE_PRPSINFO_T)
7166 typedef prpsinfo_t   elfcore_psinfo_t;
7167 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
7168 typedef prpsinfo32_t elfcore_psinfo32_t;
7169 #endif
7170 #endif
7171
7172 #if defined (HAVE_PSINFO_T)
7173 typedef psinfo_t   elfcore_psinfo_t;
7174 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
7175 typedef psinfo32_t elfcore_psinfo32_t;
7176 #endif
7177 #endif
7178
7179 /* return a malloc'ed copy of a string at START which is at
7180    most MAX bytes long, possibly without a terminating '\0'.
7181    the copy will always have a terminating '\0'.  */
7182
7183 char *
7184 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7185 {
7186   char *dups;
7187   char *end = memchr (start, '\0', max);
7188   size_t len;
7189
7190   if (end == NULL)
7191     len = max;
7192   else
7193     len = end - start;
7194
7195   dups = bfd_alloc (abfd, len + 1);
7196   if (dups == NULL)
7197     return NULL;
7198
7199   memcpy (dups, start, len);
7200   dups[len] = '\0';
7201
7202   return dups;
7203 }
7204
7205 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7206 static bfd_boolean
7207 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7208 {
7209   if (note->descsz == sizeof (elfcore_psinfo_t))
7210     {
7211       elfcore_psinfo_t psinfo;
7212
7213       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7214
7215       elf_tdata (abfd)->core_program
7216         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7217                                 sizeof (psinfo.pr_fname));
7218
7219       elf_tdata (abfd)->core_command
7220         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7221                                 sizeof (psinfo.pr_psargs));
7222     }
7223 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7224   else if (note->descsz == sizeof (elfcore_psinfo32_t))
7225     {
7226       /* 64-bit host, 32-bit corefile */
7227       elfcore_psinfo32_t psinfo;
7228
7229       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7230
7231       elf_tdata (abfd)->core_program
7232         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7233                                 sizeof (psinfo.pr_fname));
7234
7235       elf_tdata (abfd)->core_command
7236         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7237                                 sizeof (psinfo.pr_psargs));
7238     }
7239 #endif
7240
7241   else
7242     {
7243       /* Fail - we don't know how to handle any other
7244          note size (ie. data object type).  */
7245       return TRUE;
7246     }
7247
7248   /* Note that for some reason, a spurious space is tacked
7249      onto the end of the args in some (at least one anyway)
7250      implementations, so strip it off if it exists.  */
7251
7252   {
7253     char *command = elf_tdata (abfd)->core_command;
7254     int n = strlen (command);
7255
7256     if (0 < n && command[n - 1] == ' ')
7257       command[n - 1] = '\0';
7258   }
7259
7260   return TRUE;
7261 }
7262 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7263
7264 #if defined (HAVE_PSTATUS_T)
7265 static bfd_boolean
7266 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7267 {
7268   if (note->descsz == sizeof (pstatus_t)
7269 #if defined (HAVE_PXSTATUS_T)
7270       || note->descsz == sizeof (pxstatus_t)
7271 #endif
7272       )
7273     {
7274       pstatus_t pstat;
7275
7276       memcpy (&pstat, note->descdata, sizeof (pstat));
7277
7278       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7279     }
7280 #if defined (HAVE_PSTATUS32_T)
7281   else if (note->descsz == sizeof (pstatus32_t))
7282     {
7283       /* 64-bit host, 32-bit corefile */
7284       pstatus32_t pstat;
7285
7286       memcpy (&pstat, note->descdata, sizeof (pstat));
7287
7288       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7289     }
7290 #endif
7291   /* Could grab some more details from the "representative"
7292      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7293      NT_LWPSTATUS note, presumably.  */
7294
7295   return TRUE;
7296 }
7297 #endif /* defined (HAVE_PSTATUS_T) */
7298
7299 #if defined (HAVE_LWPSTATUS_T)
7300 static bfd_boolean
7301 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7302 {
7303   lwpstatus_t lwpstat;
7304   char buf[100];
7305   char *name;
7306   size_t len;
7307   asection *sect;
7308
7309   if (note->descsz != sizeof (lwpstat)
7310 #if defined (HAVE_LWPXSTATUS_T)
7311       && note->descsz != sizeof (lwpxstatus_t)
7312 #endif
7313       )
7314     return TRUE;
7315
7316   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7317
7318   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7319   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7320
7321   /* Make a ".reg/999" section.  */
7322
7323   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7324   len = strlen (buf) + 1;
7325   name = bfd_alloc (abfd, len);
7326   if (name == NULL)
7327     return FALSE;
7328   memcpy (name, buf, len);
7329
7330   sect = bfd_make_section_anyway (abfd, name);
7331   if (sect == NULL)
7332     return FALSE;
7333
7334 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7335   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7336   sect->filepos = note->descpos
7337     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7338 #endif
7339
7340 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7341   sect->size = sizeof (lwpstat.pr_reg);
7342   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7343 #endif
7344
7345   sect->flags = SEC_HAS_CONTENTS;
7346   sect->alignment_power = 2;
7347
7348   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7349     return FALSE;
7350
7351   /* Make a ".reg2/999" section */
7352
7353   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7354   len = strlen (buf) + 1;
7355   name = bfd_alloc (abfd, len);
7356   if (name == NULL)
7357     return FALSE;
7358   memcpy (name, buf, len);
7359
7360   sect = bfd_make_section_anyway (abfd, name);
7361   if (sect == NULL)
7362     return FALSE;
7363
7364 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7365   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7366   sect->filepos = note->descpos
7367     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7368 #endif
7369
7370 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7371   sect->size = sizeof (lwpstat.pr_fpreg);
7372   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7373 #endif
7374
7375   sect->flags = SEC_HAS_CONTENTS;
7376   sect->alignment_power = 2;
7377
7378   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7379 }
7380 #endif /* defined (HAVE_LWPSTATUS_T) */
7381
7382 #if defined (HAVE_WIN32_PSTATUS_T)
7383 static bfd_boolean
7384 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7385 {
7386   char buf[30];
7387   char *name;
7388   size_t len;
7389   asection *sect;
7390   win32_pstatus_t pstatus;
7391
7392   if (note->descsz < sizeof (pstatus))
7393     return TRUE;
7394
7395   memcpy (&pstatus, note->descdata, sizeof (pstatus));
7396
7397   switch (pstatus.data_type)
7398     {
7399     case NOTE_INFO_PROCESS:
7400       /* FIXME: need to add ->core_command.  */
7401       elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7402       elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
7403       break;
7404
7405     case NOTE_INFO_THREAD:
7406       /* Make a ".reg/999" section.  */
7407       sprintf (buf, ".reg/%ld", (long) pstatus.data.thread_info.tid);
7408
7409       len = strlen (buf) + 1;
7410       name = bfd_alloc (abfd, len);
7411       if (name == NULL)
7412         return FALSE;
7413
7414       memcpy (name, buf, len);
7415
7416       sect = bfd_make_section_anyway (abfd, name);
7417       if (sect == NULL)
7418         return FALSE;
7419
7420       sect->size = sizeof (pstatus.data.thread_info.thread_context);
7421       sect->filepos = (note->descpos
7422                        + offsetof (struct win32_pstatus,
7423                                    data.thread_info.thread_context));
7424       sect->flags = SEC_HAS_CONTENTS;
7425       sect->alignment_power = 2;
7426
7427       if (pstatus.data.thread_info.is_active_thread)
7428         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7429           return FALSE;
7430       break;
7431
7432     case NOTE_INFO_MODULE:
7433       /* Make a ".module/xxxxxxxx" section.  */
7434       sprintf (buf, ".module/%08lx",
7435                (long) pstatus.data.module_info.base_address);
7436
7437       len = strlen (buf) + 1;
7438       name = bfd_alloc (abfd, len);
7439       if (name == NULL)
7440         return FALSE;
7441
7442       memcpy (name, buf, len);
7443
7444       sect = bfd_make_section_anyway (abfd, name);
7445
7446       if (sect == NULL)
7447         return FALSE;
7448
7449       sect->size = note->descsz;
7450       sect->filepos = note->descpos;
7451       sect->flags = SEC_HAS_CONTENTS;
7452       sect->alignment_power = 2;
7453       break;
7454
7455     default:
7456       return TRUE;
7457     }
7458
7459   return TRUE;
7460 }
7461 #endif /* HAVE_WIN32_PSTATUS_T */
7462
7463 static bfd_boolean
7464 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7465 {
7466   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7467
7468   switch (note->type)
7469     {
7470     default:
7471       return TRUE;
7472
7473     case NT_PRSTATUS:
7474       if (bed->elf_backend_grok_prstatus)
7475         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7476           return TRUE;
7477 #if defined (HAVE_PRSTATUS_T)
7478       return elfcore_grok_prstatus (abfd, note);
7479 #else
7480       return TRUE;
7481 #endif
7482
7483 #if defined (HAVE_PSTATUS_T)
7484     case NT_PSTATUS:
7485       return elfcore_grok_pstatus (abfd, note);
7486 #endif
7487
7488 #if defined (HAVE_LWPSTATUS_T)
7489     case NT_LWPSTATUS:
7490       return elfcore_grok_lwpstatus (abfd, note);
7491 #endif
7492
7493     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
7494       return elfcore_grok_prfpreg (abfd, note);
7495
7496 #if defined (HAVE_WIN32_PSTATUS_T)
7497     case NT_WIN32PSTATUS:
7498       return elfcore_grok_win32pstatus (abfd, note);
7499 #endif
7500
7501     case NT_PRXFPREG:           /* Linux SSE extension */
7502       if (note->namesz == 6
7503           && strcmp (note->namedata, "LINUX") == 0)
7504         return elfcore_grok_prxfpreg (abfd, note);
7505       else
7506         return TRUE;
7507
7508     case NT_PRPSINFO:
7509     case NT_PSINFO:
7510       if (bed->elf_backend_grok_psinfo)
7511         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7512           return TRUE;
7513 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7514       return elfcore_grok_psinfo (abfd, note);
7515 #else
7516       return TRUE;
7517 #endif
7518
7519     case NT_AUXV:
7520       {
7521         asection *sect = bfd_make_section_anyway (abfd, ".auxv");
7522
7523         if (sect == NULL)
7524           return FALSE;
7525         sect->size = note->descsz;
7526         sect->filepos = note->descpos;
7527         sect->flags = SEC_HAS_CONTENTS;
7528         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7529
7530         return TRUE;
7531       }
7532     }
7533 }
7534
7535 static bfd_boolean
7536 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7537 {
7538   char *cp;
7539
7540   cp = strchr (note->namedata, '@');
7541   if (cp != NULL)
7542     {
7543       *lwpidp = atoi(cp + 1);
7544       return TRUE;
7545     }
7546   return FALSE;
7547 }
7548
7549 static bfd_boolean
7550 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
7551 {
7552
7553   /* Signal number at offset 0x08. */
7554   elf_tdata (abfd)->core_signal
7555     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7556
7557   /* Process ID at offset 0x50. */
7558   elf_tdata (abfd)->core_pid
7559     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7560
7561   /* Command name at 0x7c (max 32 bytes, including nul). */
7562   elf_tdata (abfd)->core_command
7563     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7564
7565   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7566                                           note);
7567 }
7568
7569 static bfd_boolean
7570 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
7571 {
7572   int lwp;
7573
7574   if (elfcore_netbsd_get_lwpid (note, &lwp))
7575     elf_tdata (abfd)->core_lwpid = lwp;
7576
7577   if (note->type == NT_NETBSDCORE_PROCINFO)
7578     {
7579       /* NetBSD-specific core "procinfo".  Note that we expect to
7580          find this note before any of the others, which is fine,
7581          since the kernel writes this note out first when it
7582          creates a core file.  */
7583
7584       return elfcore_grok_netbsd_procinfo (abfd, note);
7585     }
7586
7587   /* As of Jan 2002 there are no other machine-independent notes
7588      defined for NetBSD core files.  If the note type is less
7589      than the start of the machine-dependent note types, we don't
7590      understand it.  */
7591
7592   if (note->type < NT_NETBSDCORE_FIRSTMACH)
7593     return TRUE;
7594
7595
7596   switch (bfd_get_arch (abfd))
7597     {
7598     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7599        PT_GETFPREGS == mach+2.  */
7600
7601     case bfd_arch_alpha:
7602     case bfd_arch_sparc:
7603       switch (note->type)
7604         {
7605         case NT_NETBSDCORE_FIRSTMACH+0:
7606           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7607
7608         case NT_NETBSDCORE_FIRSTMACH+2:
7609           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7610
7611         default:
7612           return TRUE;
7613         }
7614
7615     /* On all other arch's, PT_GETREGS == mach+1 and
7616        PT_GETFPREGS == mach+3.  */
7617
7618     default:
7619       switch (note->type)
7620         {
7621         case NT_NETBSDCORE_FIRSTMACH+1:
7622           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7623
7624         case NT_NETBSDCORE_FIRSTMACH+3:
7625           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7626
7627         default:
7628           return TRUE;
7629         }
7630     }
7631     /* NOTREACHED */
7632 }
7633
7634 static bfd_boolean
7635 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
7636 {
7637   void *ddata = note->descdata;
7638   char buf[100];
7639   char *name;
7640   asection *sect;
7641   short sig;
7642   unsigned flags;
7643
7644   /* nto_procfs_status 'pid' field is at offset 0.  */
7645   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
7646
7647   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
7648   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
7649
7650   /* nto_procfs_status 'flags' field is at offset 8.  */
7651   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
7652
7653   /* nto_procfs_status 'what' field is at offset 14.  */
7654   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
7655     {
7656       elf_tdata (abfd)->core_signal = sig;
7657       elf_tdata (abfd)->core_lwpid = *tid;
7658     }
7659
7660   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
7661      do not come from signals so we make sure we set the current
7662      thread just in case.  */
7663   if (flags & 0x00000080)
7664     elf_tdata (abfd)->core_lwpid = *tid;
7665
7666   /* Make a ".qnx_core_status/%d" section.  */
7667   sprintf (buf, ".qnx_core_status/%ld", (long) *tid);
7668
7669   name = bfd_alloc (abfd, strlen (buf) + 1);
7670   if (name == NULL)
7671     return FALSE;
7672   strcpy (name, buf);
7673
7674   sect = bfd_make_section_anyway (abfd, name);
7675   if (sect == NULL)
7676     return FALSE;
7677
7678   sect->size            = note->descsz;
7679   sect->filepos         = note->descpos;
7680   sect->flags           = SEC_HAS_CONTENTS;
7681   sect->alignment_power = 2;
7682
7683   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
7684 }
7685
7686 static bfd_boolean
7687 elfcore_grok_nto_regs (bfd *abfd,
7688                        Elf_Internal_Note *note,
7689                        pid_t tid,
7690                        char *base)
7691 {
7692   char buf[100];
7693   char *name;
7694   asection *sect;
7695
7696   /* Make a "(base)/%d" section.  */
7697   sprintf (buf, "%s/%ld", base, (long) tid);
7698
7699   name = bfd_alloc (abfd, strlen (buf) + 1);
7700   if (name == NULL)
7701     return FALSE;
7702   strcpy (name, buf);
7703
7704   sect = bfd_make_section_anyway (abfd, name);
7705   if (sect == NULL)
7706     return FALSE;
7707
7708   sect->size            = note->descsz;
7709   sect->filepos         = note->descpos;
7710   sect->flags           = SEC_HAS_CONTENTS;
7711   sect->alignment_power = 2;
7712
7713   /* This is the current thread.  */
7714   if (elf_tdata (abfd)->core_lwpid == tid)
7715     return elfcore_maybe_make_sect (abfd, base, sect);
7716
7717   return TRUE;
7718 }
7719
7720 #define BFD_QNT_CORE_INFO       7
7721 #define BFD_QNT_CORE_STATUS     8
7722 #define BFD_QNT_CORE_GREG       9
7723 #define BFD_QNT_CORE_FPREG      10
7724
7725 static bfd_boolean
7726 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
7727 {
7728   /* Every GREG section has a STATUS section before it.  Store the
7729      tid from the previous call to pass down to the next gregs
7730      function.  */
7731   static pid_t tid = 1;
7732
7733   switch (note->type)
7734     {
7735     case BFD_QNT_CORE_INFO:
7736       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7737     case BFD_QNT_CORE_STATUS:
7738       return elfcore_grok_nto_status (abfd, note, &tid);
7739     case BFD_QNT_CORE_GREG:
7740       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
7741     case BFD_QNT_CORE_FPREG:
7742       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
7743     default:
7744       return TRUE;
7745     }
7746 }
7747
7748 /* Function: elfcore_write_note
7749
7750    Inputs:
7751      buffer to hold note
7752      name of note
7753      type of note
7754      data for note
7755      size of data for note
7756
7757    Return:
7758    End of buffer containing note.  */
7759
7760 char *
7761 elfcore_write_note (bfd  *abfd,
7762                     char *buf,
7763                     int  *bufsiz,
7764                     const char *name,
7765                     int  type,
7766                     const void *input,
7767                     int  size)
7768 {
7769   Elf_External_Note *xnp;
7770   size_t namesz;
7771   size_t pad;
7772   size_t newspace;
7773   char *p, *dest;
7774
7775   namesz = 0;
7776   pad = 0;
7777   if (name != NULL)
7778     {
7779       const struct elf_backend_data *bed;
7780
7781       namesz = strlen (name) + 1;
7782       bed = get_elf_backend_data (abfd);
7783       pad = -namesz & ((1 << bed->s->log_file_align) - 1);
7784     }
7785
7786   newspace = 12 + namesz + pad + size;
7787
7788   p = realloc (buf, *bufsiz + newspace);
7789   dest = p + *bufsiz;
7790   *bufsiz += newspace;
7791   xnp = (Elf_External_Note *) dest;
7792   H_PUT_32 (abfd, namesz, xnp->namesz);
7793   H_PUT_32 (abfd, size, xnp->descsz);
7794   H_PUT_32 (abfd, type, xnp->type);
7795   dest = xnp->name;
7796   if (name != NULL)
7797     {
7798       memcpy (dest, name, namesz);
7799       dest += namesz;
7800       while (pad != 0)
7801         {
7802           *dest++ = '\0';
7803           --pad;
7804         }
7805     }
7806   memcpy (dest, input, size);
7807   return p;
7808 }
7809
7810 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7811 char *
7812 elfcore_write_prpsinfo (bfd  *abfd,
7813                         char *buf,
7814                         int  *bufsiz,
7815                         const char *fname,
7816                         const char *psargs)
7817 {
7818   int note_type;
7819   char *note_name = "CORE";
7820
7821 #if defined (HAVE_PSINFO_T)
7822   psinfo_t  data;
7823   note_type = NT_PSINFO;
7824 #else
7825   prpsinfo_t data;
7826   note_type = NT_PRPSINFO;
7827 #endif
7828
7829   memset (&data, 0, sizeof (data));
7830   strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7831   strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7832   return elfcore_write_note (abfd, buf, bufsiz,
7833                              note_name, note_type, &data, sizeof (data));
7834 }
7835 #endif  /* PSINFO_T or PRPSINFO_T */
7836
7837 #if defined (HAVE_PRSTATUS_T)
7838 char *
7839 elfcore_write_prstatus (bfd *abfd,
7840                         char *buf,
7841                         int *bufsiz,
7842                         long pid,
7843                         int cursig,
7844                         const void *gregs)
7845 {
7846   prstatus_t prstat;
7847   char *note_name = "CORE";
7848
7849   memset (&prstat, 0, sizeof (prstat));
7850   prstat.pr_pid = pid;
7851   prstat.pr_cursig = cursig;
7852   memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7853   return elfcore_write_note (abfd, buf, bufsiz,
7854                              note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7855 }
7856 #endif /* HAVE_PRSTATUS_T */
7857
7858 #if defined (HAVE_LWPSTATUS_T)
7859 char *
7860 elfcore_write_lwpstatus (bfd *abfd,
7861                          char *buf,
7862                          int *bufsiz,
7863                          long pid,
7864                          int cursig,
7865                          const void *gregs)
7866 {
7867   lwpstatus_t lwpstat;
7868   char *note_name = "CORE";
7869
7870   memset (&lwpstat, 0, sizeof (lwpstat));
7871   lwpstat.pr_lwpid  = pid >> 16;
7872   lwpstat.pr_cursig = cursig;
7873 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7874   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7875 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7876 #if !defined(gregs)
7877   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7878           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7879 #else
7880   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7881           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7882 #endif
7883 #endif
7884   return elfcore_write_note (abfd, buf, bufsiz, note_name,
7885                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7886 }
7887 #endif /* HAVE_LWPSTATUS_T */
7888
7889 #if defined (HAVE_PSTATUS_T)
7890 char *
7891 elfcore_write_pstatus (bfd *abfd,
7892                        char *buf,
7893                        int *bufsiz,
7894                        long pid,
7895                        int cursig,
7896                        const void *gregs)
7897 {
7898   pstatus_t pstat;
7899   char *note_name = "CORE";
7900
7901   memset (&pstat, 0, sizeof (pstat));
7902   pstat.pr_pid = pid & 0xffff;
7903   buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
7904                             NT_PSTATUS, &pstat, sizeof (pstat));
7905   return buf;
7906 }
7907 #endif /* HAVE_PSTATUS_T */
7908
7909 char *
7910 elfcore_write_prfpreg (bfd *abfd,
7911                        char *buf,
7912                        int *bufsiz,
7913                        const void *fpregs,
7914                        int size)
7915 {
7916   char *note_name = "CORE";
7917   return elfcore_write_note (abfd, buf, bufsiz,
7918                              note_name, NT_FPREGSET, fpregs, size);
7919 }
7920
7921 char *
7922 elfcore_write_prxfpreg (bfd *abfd,
7923                         char *buf,
7924                         int *bufsiz,
7925                         const void *xfpregs,
7926                         int size)
7927 {
7928   char *note_name = "LINUX";
7929   return elfcore_write_note (abfd, buf, bufsiz,
7930                              note_name, NT_PRXFPREG, xfpregs, size);
7931 }
7932
7933 static bfd_boolean
7934 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
7935 {
7936   char *buf;
7937   char *p;
7938
7939   if (size <= 0)
7940     return TRUE;
7941
7942   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
7943     return FALSE;
7944
7945   buf = bfd_malloc (size);
7946   if (buf == NULL)
7947     return FALSE;
7948
7949   if (bfd_bread (buf, size, abfd) != size)
7950     {
7951     error:
7952       free (buf);
7953       return FALSE;
7954     }
7955
7956   p = buf;
7957   while (p < buf + size)
7958     {
7959       /* FIXME: bad alignment assumption.  */
7960       Elf_External_Note *xnp = (Elf_External_Note *) p;
7961       Elf_Internal_Note in;
7962
7963       in.type = H_GET_32 (abfd, xnp->type);
7964
7965       in.namesz = H_GET_32 (abfd, xnp->namesz);
7966       in.namedata = xnp->name;
7967
7968       in.descsz = H_GET_32 (abfd, xnp->descsz);
7969       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7970       in.descpos = offset + (in.descdata - buf);
7971
7972       if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7973         {
7974           if (! elfcore_grok_netbsd_note (abfd, &in))
7975             goto error;
7976         }
7977       else if (strncmp (in.namedata, "QNX", 3) == 0)
7978         {
7979           if (! elfcore_grok_nto_note (abfd, &in))
7980             goto error;
7981         }
7982       else
7983         {
7984           if (! elfcore_grok_note (abfd, &in))
7985             goto error;
7986         }
7987
7988       p = in.descdata + BFD_ALIGN (in.descsz, 4);
7989     }
7990
7991   free (buf);
7992   return TRUE;
7993 }
7994 \f
7995 /* Providing external access to the ELF program header table.  */
7996
7997 /* Return an upper bound on the number of bytes required to store a
7998    copy of ABFD's program header table entries.  Return -1 if an error
7999    occurs; bfd_get_error will return an appropriate code.  */
8000
8001 long
8002 bfd_get_elf_phdr_upper_bound (bfd *abfd)
8003 {
8004   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8005     {
8006       bfd_set_error (bfd_error_wrong_format);
8007       return -1;
8008     }
8009
8010   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
8011 }
8012
8013 /* Copy ABFD's program header table entries to *PHDRS.  The entries
8014    will be stored as an array of Elf_Internal_Phdr structures, as
8015    defined in include/elf/internal.h.  To find out how large the
8016    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8017
8018    Return the number of program header table entries read, or -1 if an
8019    error occurs; bfd_get_error will return an appropriate code.  */
8020
8021 int
8022 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
8023 {
8024   int num_phdrs;
8025
8026   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8027     {
8028       bfd_set_error (bfd_error_wrong_format);
8029       return -1;
8030     }
8031
8032   num_phdrs = elf_elfheader (abfd)->e_phnum;
8033   memcpy (phdrs, elf_tdata (abfd)->phdr,
8034           num_phdrs * sizeof (Elf_Internal_Phdr));
8035
8036   return num_phdrs;
8037 }
8038
8039 void
8040 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
8041 {
8042 #ifdef BFD64
8043   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
8044
8045   i_ehdrp = elf_elfheader (abfd);
8046   if (i_ehdrp == NULL)
8047     sprintf_vma (buf, value);
8048   else
8049     {
8050       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
8051         {
8052 #if BFD_HOST_64BIT_LONG
8053           sprintf (buf, "%016lx", value);
8054 #else
8055           sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
8056                    _bfd_int64_low (value));
8057 #endif
8058         }
8059       else
8060         sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
8061     }
8062 #else
8063   sprintf_vma (buf, value);
8064 #endif
8065 }
8066
8067 void
8068 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
8069 {
8070 #ifdef BFD64
8071   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
8072
8073   i_ehdrp = elf_elfheader (abfd);
8074   if (i_ehdrp == NULL)
8075     fprintf_vma ((FILE *) stream, value);
8076   else
8077     {
8078       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
8079         {
8080 #if BFD_HOST_64BIT_LONG
8081           fprintf ((FILE *) stream, "%016lx", value);
8082 #else
8083           fprintf ((FILE *) stream, "%08lx%08lx",
8084                    _bfd_int64_high (value), _bfd_int64_low (value));
8085 #endif
8086         }
8087       else
8088         fprintf ((FILE *) stream, "%08lx",
8089                  (unsigned long) (value & 0xffffffff));
8090     }
8091 #else
8092   fprintf_vma ((FILE *) stream, value);
8093 #endif
8094 }
8095
8096 enum elf_reloc_type_class
8097 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8098 {
8099   return reloc_class_normal;
8100 }
8101
8102 /* For RELA architectures, return the relocation value for a
8103    relocation against a local symbol.  */
8104
8105 bfd_vma
8106 _bfd_elf_rela_local_sym (bfd *abfd,
8107                          Elf_Internal_Sym *sym,
8108                          asection **psec,
8109                          Elf_Internal_Rela *rel)
8110 {
8111   asection *sec = *psec;
8112   bfd_vma relocation;
8113
8114   relocation = (sec->output_section->vma
8115                 + sec->output_offset
8116                 + sym->st_value);
8117   if ((sec->flags & SEC_MERGE)
8118       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8119       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8120     {
8121       rel->r_addend =
8122         _bfd_merged_section_offset (abfd, psec,
8123                                     elf_section_data (sec)->sec_info,
8124                                     sym->st_value + rel->r_addend);
8125       if (sec != *psec)
8126         {
8127           /* If we have changed the section, and our original section is
8128              marked with SEC_EXCLUDE, it means that the original
8129              SEC_MERGE section has been completely subsumed in some
8130              other SEC_MERGE section.  In this case, we need to leave
8131              some info around for --emit-relocs.  */
8132           if ((sec->flags & SEC_EXCLUDE) != 0)
8133             sec->kept_section = *psec;
8134           sec = *psec;
8135         }
8136       rel->r_addend -= relocation;
8137       rel->r_addend += sec->output_section->vma + sec->output_offset;
8138     }
8139   return relocation;
8140 }
8141
8142 bfd_vma
8143 _bfd_elf_rel_local_sym (bfd *abfd,
8144                         Elf_Internal_Sym *sym,
8145                         asection **psec,
8146                         bfd_vma addend)
8147 {
8148   asection *sec = *psec;
8149
8150   if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8151     return sym->st_value + addend;
8152
8153   return _bfd_merged_section_offset (abfd, psec,
8154                                      elf_section_data (sec)->sec_info,
8155                                      sym->st_value + addend);
8156 }
8157
8158 bfd_vma
8159 _bfd_elf_section_offset (bfd *abfd,
8160                          struct bfd_link_info *info,
8161                          asection *sec,
8162                          bfd_vma offset)
8163 {
8164   switch (sec->sec_info_type)
8165     {
8166     case ELF_INFO_TYPE_STABS:
8167       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8168                                        offset);
8169     case ELF_INFO_TYPE_EH_FRAME:
8170       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8171     default:
8172       return offset;
8173     }
8174 }
8175 \f
8176 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
8177    reconstruct an ELF file by reading the segments out of remote memory
8178    based on the ELF file header at EHDR_VMA and the ELF program headers it
8179    points to.  If not null, *LOADBASEP is filled in with the difference
8180    between the VMAs from which the segments were read, and the VMAs the
8181    file headers (and hence BFD's idea of each section's VMA) put them at.
8182
8183    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8184    remote memory at target address VMA into the local buffer at MYADDR; it
8185    should return zero on success or an `errno' code on failure.  TEMPL must
8186    be a BFD for an ELF target with the word size and byte order found in
8187    the remote memory.  */
8188
8189 bfd *
8190 bfd_elf_bfd_from_remote_memory
8191   (bfd *templ,
8192    bfd_vma ehdr_vma,
8193    bfd_vma *loadbasep,
8194    int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8195 {
8196   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8197     (templ, ehdr_vma, loadbasep, target_read_memory);
8198 }
8199 \f
8200 long
8201 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8202                                long symcount ATTRIBUTE_UNUSED,
8203                                asymbol **syms ATTRIBUTE_UNUSED,
8204                                long dynsymcount,
8205                                asymbol **dynsyms,
8206                                asymbol **ret)
8207 {
8208   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8209   asection *relplt;
8210   asymbol *s;
8211   const char *relplt_name;
8212   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8213   arelent *p;
8214   long count, i, n;
8215   size_t size;
8216   Elf_Internal_Shdr *hdr;
8217   char *names;
8218   asection *plt;
8219
8220   *ret = NULL;
8221
8222   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8223     return 0;
8224
8225   if (dynsymcount <= 0)
8226     return 0;
8227
8228   if (!bed->plt_sym_val)
8229     return 0;
8230
8231   relplt_name = bed->relplt_name;
8232   if (relplt_name == NULL)
8233     relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8234   relplt = bfd_get_section_by_name (abfd, relplt_name);
8235   if (relplt == NULL)
8236     return 0;
8237
8238   hdr = &elf_section_data (relplt)->this_hdr;
8239   if (hdr->sh_link != elf_dynsymtab (abfd)
8240       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8241     return 0;
8242
8243   plt = bfd_get_section_by_name (abfd, ".plt");
8244   if (plt == NULL)
8245     return 0;
8246
8247   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8248   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8249     return -1;
8250
8251   count = relplt->size / hdr->sh_entsize;
8252   size = count * sizeof (asymbol);
8253   p = relplt->relocation;
8254   for (i = 0; i < count; i++, s++, p++)
8255     size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8256
8257   s = *ret = bfd_malloc (size);
8258   if (s == NULL)
8259     return -1;
8260
8261   names = (char *) (s + count);
8262   p = relplt->relocation;
8263   n = 0;
8264   for (i = 0; i < count; i++, s++, p++)
8265     {
8266       size_t len;
8267       bfd_vma addr;
8268
8269       addr = bed->plt_sym_val (i, plt, p);
8270       if (addr == (bfd_vma) -1)
8271         continue;
8272
8273       *s = **p->sym_ptr_ptr;
8274       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
8275          we are defining a symbol, ensure one of them is set.  */
8276       if ((s->flags & BSF_LOCAL) == 0)
8277         s->flags |= BSF_GLOBAL;
8278       s->section = plt;
8279       s->value = addr - plt->vma;
8280       s->name = names;
8281       len = strlen ((*p->sym_ptr_ptr)->name);
8282       memcpy (names, (*p->sym_ptr_ptr)->name, len);
8283       names += len;
8284       memcpy (names, "@plt", sizeof ("@plt"));
8285       names += sizeof ("@plt");
8286       ++n;
8287     }
8288
8289   return n;
8290 }
8291
8292 /* Sort symbol by binding and section. We want to put definitions
8293    sorted by section at the beginning.  */
8294
8295 static int
8296 elf_sort_elf_symbol (const void *arg1, const void *arg2)
8297 {
8298   const Elf_Internal_Sym *s1;
8299   const Elf_Internal_Sym *s2;
8300   int shndx;
8301
8302   /* Make sure that undefined symbols are at the end.  */
8303   s1 = (const Elf_Internal_Sym *) arg1;
8304   if (s1->st_shndx == SHN_UNDEF)
8305     return 1;
8306   s2 = (const Elf_Internal_Sym *) arg2;
8307   if (s2->st_shndx == SHN_UNDEF)
8308     return -1;
8309
8310   /* Sorted by section index.  */
8311   shndx = s1->st_shndx - s2->st_shndx;
8312   if (shndx != 0)
8313     return shndx;
8314
8315   /* Sorted by binding.  */
8316   return ELF_ST_BIND (s1->st_info)  - ELF_ST_BIND (s2->st_info);
8317 }
8318
8319 struct elf_symbol
8320 {
8321   Elf_Internal_Sym *sym;
8322   const char *name;
8323 };
8324
8325 static int
8326 elf_sym_name_compare (const void *arg1, const void *arg2)
8327 {
8328   const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
8329   const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
8330   return strcmp (s1->name, s2->name);
8331 }
8332
8333 /* Check if 2 sections define the same set of local and global
8334    symbols.  */
8335
8336 bfd_boolean
8337 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2)
8338 {
8339   bfd *bfd1, *bfd2;
8340   const struct elf_backend_data *bed1, *bed2;
8341   Elf_Internal_Shdr *hdr1, *hdr2;
8342   bfd_size_type symcount1, symcount2;
8343   Elf_Internal_Sym *isymbuf1, *isymbuf2;
8344   Elf_Internal_Sym *isymstart1 = NULL, *isymstart2 = NULL, *isym;
8345   Elf_Internal_Sym *isymend;
8346   struct elf_symbol *symp, *symtable1 = NULL, *symtable2 = NULL;
8347   bfd_size_type count1, count2, i;
8348   int shndx1, shndx2;
8349   bfd_boolean result;
8350
8351   bfd1 = sec1->owner;
8352   bfd2 = sec2->owner;
8353
8354   /* If both are .gnu.linkonce sections, they have to have the same
8355      section name.  */
8356   if (strncmp (sec1->name, ".gnu.linkonce",
8357                sizeof ".gnu.linkonce" - 1) == 0
8358       && strncmp (sec2->name, ".gnu.linkonce",
8359                   sizeof ".gnu.linkonce" - 1) == 0)
8360     return strcmp (sec1->name + sizeof ".gnu.linkonce",
8361                    sec2->name + sizeof ".gnu.linkonce") == 0;
8362
8363   /* Both sections have to be in ELF.  */
8364   if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
8365       || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
8366     return FALSE;
8367
8368   if (elf_section_type (sec1) != elf_section_type (sec2))
8369     return FALSE;
8370
8371   if ((elf_section_flags (sec1) & SHF_GROUP) != 0
8372       && (elf_section_flags (sec2) & SHF_GROUP) != 0)
8373     {
8374       /* If both are members of section groups, they have to have the
8375          same group name.  */
8376       if (strcmp (elf_group_name (sec1), elf_group_name (sec2)) != 0)
8377         return FALSE;
8378     }
8379
8380   shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
8381   shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
8382   if (shndx1 == -1 || shndx2 == -1)
8383     return FALSE;
8384
8385   bed1 = get_elf_backend_data (bfd1);
8386   bed2 = get_elf_backend_data (bfd2);
8387   hdr1 = &elf_tdata (bfd1)->symtab_hdr;
8388   symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
8389   hdr2 = &elf_tdata (bfd2)->symtab_hdr;
8390   symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
8391
8392   if (symcount1 == 0 || symcount2 == 0)
8393     return FALSE;
8394
8395   isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
8396                                    NULL, NULL, NULL);
8397   isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
8398                                    NULL, NULL, NULL);
8399
8400   result = FALSE;
8401   if (isymbuf1 == NULL || isymbuf2 == NULL)
8402     goto done;
8403
8404   /* Sort symbols by binding and section. Global definitions are at
8405      the beginning.  */
8406   qsort (isymbuf1, symcount1, sizeof (Elf_Internal_Sym),
8407          elf_sort_elf_symbol);
8408   qsort (isymbuf2, symcount2, sizeof (Elf_Internal_Sym),
8409          elf_sort_elf_symbol);
8410
8411   /* Count definitions in the section.  */
8412   count1 = 0;
8413   for (isym = isymbuf1, isymend = isym + symcount1;
8414        isym < isymend; isym++)
8415     {
8416       if (isym->st_shndx == (unsigned int) shndx1)
8417         {
8418           if (count1 == 0)
8419             isymstart1 = isym;
8420           count1++;
8421         }
8422
8423       if (count1 && isym->st_shndx != (unsigned int) shndx1)
8424         break;
8425     }
8426
8427   count2 = 0;
8428   for (isym = isymbuf2, isymend = isym + symcount2;
8429        isym < isymend; isym++)
8430     {
8431       if (isym->st_shndx == (unsigned int) shndx2)
8432         {
8433           if (count2 == 0)
8434             isymstart2 = isym;
8435           count2++;
8436         }
8437
8438       if (count2 && isym->st_shndx != (unsigned int) shndx2)
8439         break;
8440     }
8441
8442   if (count1 == 0 || count2 == 0 || count1 != count2)
8443     goto done;
8444
8445   symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8446   symtable2 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8447
8448   if (symtable1 == NULL || symtable2 == NULL)
8449     goto done;
8450
8451   symp = symtable1;
8452   for (isym = isymstart1, isymend = isym + count1;
8453        isym < isymend; isym++)
8454     {
8455       symp->sym = isym;
8456       symp->name = bfd_elf_string_from_elf_section (bfd1,
8457                                                     hdr1->sh_link,
8458                                                     isym->st_name);
8459       symp++;
8460     }
8461
8462   symp = symtable2;
8463   for (isym = isymstart2, isymend = isym + count1;
8464        isym < isymend; isym++)
8465     {
8466       symp->sym = isym;
8467       symp->name = bfd_elf_string_from_elf_section (bfd2,
8468                                                     hdr2->sh_link,
8469                                                     isym->st_name);
8470       symp++;
8471     }
8472
8473   /* Sort symbol by name.  */
8474   qsort (symtable1, count1, sizeof (struct elf_symbol),
8475          elf_sym_name_compare);
8476   qsort (symtable2, count1, sizeof (struct elf_symbol),
8477          elf_sym_name_compare);
8478
8479   for (i = 0; i < count1; i++)
8480     /* Two symbols must have the same binding, type and name.  */
8481     if (symtable1 [i].sym->st_info != symtable2 [i].sym->st_info
8482         || symtable1 [i].sym->st_other != symtable2 [i].sym->st_other
8483         || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
8484       goto done;
8485
8486   result = TRUE;
8487
8488 done:
8489   if (symtable1)
8490     free (symtable1);
8491   if (symtable2)
8492     free (symtable2);
8493   if (isymbuf1)
8494     free (isymbuf1);
8495   if (isymbuf2)
8496     free (isymbuf2);
8497
8498   return result;
8499 }
8500
8501 /* It is only used by x86-64 so far.  */
8502 asection _bfd_elf_large_com_section
8503   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
8504                       SEC_IS_COMMON, NULL, NULL, "LARGE_COMMON",
8505                       0);
8506
8507 /* Return TRUE if 2 section types are compatible.  */
8508
8509 bfd_boolean
8510 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
8511                                  bfd *bbfd, const asection *bsec)
8512 {
8513   if (asec == NULL
8514       || bsec == NULL
8515       || abfd->xvec->flavour != bfd_target_elf_flavour
8516       || bbfd->xvec->flavour != bfd_target_elf_flavour)
8517     return TRUE;
8518
8519   return elf_section_type (asec) == elf_section_type (bsec);
8520 }