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