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