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