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_zalloc (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   if (ibfd->xvec == obfd->xvec)
6360     {
6361       /* When rewriting program header, set the output maxpagesize to
6362          the maximum alignment of input PT_LOAD segments.  */
6363       Elf_Internal_Phdr *segment;
6364       unsigned int i;
6365       unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
6366       bfd_vma maxpagesize = 0;
6367
6368       for (i = 0, segment = elf_tdata (ibfd)->phdr;
6369            i < num_segments;
6370            i++, segment++)
6371         if (segment->p_type == PT_LOAD
6372             && maxpagesize < segment->p_align)
6373           maxpagesize = segment->p_align;
6374
6375       if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
6376         bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
6377     }
6378
6379   return rewrite_elf_program_header (ibfd, obfd);
6380 }
6381
6382 /* Initialize private output section information from input section.  */
6383
6384 bfd_boolean
6385 _bfd_elf_init_private_section_data (bfd *ibfd,
6386                                     asection *isec,
6387                                     bfd *obfd,
6388                                     asection *osec,
6389                                     struct bfd_link_info *link_info)
6390
6391 {
6392   Elf_Internal_Shdr *ihdr, *ohdr;
6393   bfd_boolean final_link = link_info != NULL && !link_info->relocatable;
6394
6395   if (ibfd->xvec->flavour != bfd_target_elf_flavour
6396       || obfd->xvec->flavour != bfd_target_elf_flavour)
6397     return TRUE;
6398
6399   BFD_ASSERT (elf_section_data (osec) != NULL);
6400
6401   /* For objcopy and relocatable link, don't copy the output ELF
6402      section type from input if the output BFD section flags have been
6403      set to something different.  For a final link allow some flags
6404      that the linker clears to differ.  */
6405   if (elf_section_type (osec) == SHT_NULL
6406       && (osec->flags == isec->flags
6407           || (final_link
6408               && ((osec->flags ^ isec->flags)
6409                   & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
6410     elf_section_type (osec) = elf_section_type (isec);
6411
6412   /* FIXME: Is this correct for all OS/PROC specific flags?  */
6413   elf_section_flags (osec) |= (elf_section_flags (isec)
6414                                & (SHF_MASKOS | SHF_MASKPROC));
6415
6416   /* Set things up for objcopy and relocatable link.  The output
6417      SHT_GROUP section will have its elf_next_in_group pointing back
6418      to the input group members.  Ignore linker created group section.
6419      See elfNN_ia64_object_p in elfxx-ia64.c.  */
6420   if (!final_link)
6421     {
6422       if (elf_sec_group (isec) == NULL
6423           || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6424         {
6425           if (elf_section_flags (isec) & SHF_GROUP)
6426             elf_section_flags (osec) |= SHF_GROUP;
6427           elf_next_in_group (osec) = elf_next_in_group (isec);
6428           elf_section_data (osec)->group = elf_section_data (isec)->group;
6429         }
6430     }
6431
6432   ihdr = &elf_section_data (isec)->this_hdr;
6433
6434   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6435      don't use the output section of the linked-to section since it
6436      may be NULL at this point.  */
6437   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6438     {
6439       ohdr = &elf_section_data (osec)->this_hdr;
6440       ohdr->sh_flags |= SHF_LINK_ORDER;
6441       elf_linked_to_section (osec) = elf_linked_to_section (isec);
6442     }
6443
6444   osec->use_rela_p = isec->use_rela_p;
6445
6446   return TRUE;
6447 }
6448
6449 /* Copy private section information.  This copies over the entsize
6450    field, and sometimes the info field.  */
6451
6452 bfd_boolean
6453 _bfd_elf_copy_private_section_data (bfd *ibfd,
6454                                     asection *isec,
6455                                     bfd *obfd,
6456                                     asection *osec)
6457 {
6458   Elf_Internal_Shdr *ihdr, *ohdr;
6459
6460   if (ibfd->xvec->flavour != bfd_target_elf_flavour
6461       || obfd->xvec->flavour != bfd_target_elf_flavour)
6462     return TRUE;
6463
6464   ihdr = &elf_section_data (isec)->this_hdr;
6465   ohdr = &elf_section_data (osec)->this_hdr;
6466
6467   ohdr->sh_entsize = ihdr->sh_entsize;
6468
6469   if (ihdr->sh_type == SHT_SYMTAB
6470       || ihdr->sh_type == SHT_DYNSYM
6471       || ihdr->sh_type == SHT_GNU_verneed
6472       || ihdr->sh_type == SHT_GNU_verdef)
6473     ohdr->sh_info = ihdr->sh_info;
6474
6475   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6476                                              NULL);
6477 }
6478
6479 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6480    necessary if we are removing either the SHT_GROUP section or any of
6481    the group member sections.  DISCARDED is the value that a section's
6482    output_section has if the section will be discarded, NULL when this
6483    function is called from objcopy, bfd_abs_section_ptr when called
6484    from the linker.  */
6485
6486 bfd_boolean
6487 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
6488 {
6489   asection *isec;
6490
6491   for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6492     if (elf_section_type (isec) == SHT_GROUP)
6493       {
6494         asection *first = elf_next_in_group (isec);
6495         asection *s = first;
6496         bfd_size_type removed = 0;
6497
6498         while (s != NULL)
6499           {
6500             /* If this member section is being output but the
6501                SHT_GROUP section is not, then clear the group info
6502                set up by _bfd_elf_copy_private_section_data.  */
6503             if (s->output_section != discarded
6504                 && isec->output_section == discarded)
6505               {
6506                 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6507                 elf_group_name (s->output_section) = NULL;
6508               }
6509             /* Conversely, if the member section is not being output
6510                but the SHT_GROUP section is, then adjust its size.  */
6511             else if (s->output_section == discarded
6512                      && isec->output_section != discarded)
6513               removed += 4;
6514             s = elf_next_in_group (s);
6515             if (s == first)
6516               break;
6517           }
6518         if (removed != 0)
6519           {
6520             if (discarded != NULL)
6521               {
6522                 /* If we've been called for ld -r, then we need to
6523                    adjust the input section size.  This function may
6524                    be called multiple times, so save the original
6525                    size.  */
6526                 if (isec->rawsize == 0)
6527                   isec->rawsize = isec->size;
6528                 isec->size = isec->rawsize - removed;
6529               }
6530             else
6531               {
6532                 /* Adjust the output section size when called from
6533                    objcopy. */
6534                 isec->output_section->size -= removed;
6535               }
6536           }
6537       }
6538
6539   return TRUE;
6540 }
6541
6542 /* Copy private header information.  */
6543
6544 bfd_boolean
6545 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6546 {
6547   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6548       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6549     return TRUE;
6550
6551   /* Copy over private BFD data if it has not already been copied.
6552      This must be done here, rather than in the copy_private_bfd_data
6553      entry point, because the latter is called after the section
6554      contents have been set, which means that the program headers have
6555      already been worked out.  */
6556   if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6557     {
6558       if (! copy_private_bfd_data (ibfd, obfd))
6559         return FALSE;
6560     }
6561
6562   return _bfd_elf_fixup_group_sections (ibfd, NULL);
6563 }
6564
6565 /* Copy private symbol information.  If this symbol is in a section
6566    which we did not map into a BFD section, try to map the section
6567    index correctly.  We use special macro definitions for the mapped
6568    section indices; these definitions are interpreted by the
6569    swap_out_syms function.  */
6570
6571 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6572 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6573 #define MAP_STRTAB    (SHN_HIOS + 3)
6574 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
6575 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6576
6577 bfd_boolean
6578 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6579                                    asymbol *isymarg,
6580                                    bfd *obfd,
6581                                    asymbol *osymarg)
6582 {
6583   elf_symbol_type *isym, *osym;
6584
6585   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6586       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6587     return TRUE;
6588
6589   isym = elf_symbol_from (ibfd, isymarg);
6590   osym = elf_symbol_from (obfd, osymarg);
6591
6592   if (isym != NULL
6593       && isym->internal_elf_sym.st_shndx != 0
6594       && osym != NULL
6595       && bfd_is_abs_section (isym->symbol.section))
6596     {
6597       unsigned int shndx;
6598
6599       shndx = isym->internal_elf_sym.st_shndx;
6600       if (shndx == elf_onesymtab (ibfd))
6601         shndx = MAP_ONESYMTAB;
6602       else if (shndx == elf_dynsymtab (ibfd))
6603         shndx = MAP_DYNSYMTAB;
6604       else if (shndx == elf_tdata (ibfd)->strtab_section)
6605         shndx = MAP_STRTAB;
6606       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6607         shndx = MAP_SHSTRTAB;
6608       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6609         shndx = MAP_SYM_SHNDX;
6610       osym->internal_elf_sym.st_shndx = shndx;
6611     }
6612
6613   return TRUE;
6614 }
6615
6616 /* Swap out the symbols.  */
6617
6618 static bfd_boolean
6619 swap_out_syms (bfd *abfd,
6620                struct bfd_strtab_hash **sttp,
6621                int relocatable_p)
6622 {
6623   const struct elf_backend_data *bed;
6624   int symcount;
6625   asymbol **syms;
6626   struct bfd_strtab_hash *stt;
6627   Elf_Internal_Shdr *symtab_hdr;
6628   Elf_Internal_Shdr *symtab_shndx_hdr;
6629   Elf_Internal_Shdr *symstrtab_hdr;
6630   bfd_byte *outbound_syms;
6631   bfd_byte *outbound_shndx;
6632   int idx;
6633   bfd_size_type amt;
6634   bfd_boolean name_local_sections;
6635
6636   if (!elf_map_symbols (abfd))
6637     return FALSE;
6638
6639   /* Dump out the symtabs.  */
6640   stt = _bfd_elf_stringtab_init ();
6641   if (stt == NULL)
6642     return FALSE;
6643
6644   bed = get_elf_backend_data (abfd);
6645   symcount = bfd_get_symcount (abfd);
6646   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6647   symtab_hdr->sh_type = SHT_SYMTAB;
6648   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6649   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6650   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6651   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
6652
6653   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6654   symstrtab_hdr->sh_type = SHT_STRTAB;
6655
6656   outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
6657                                            bed->s->sizeof_sym);
6658   if (outbound_syms == NULL)
6659     {
6660       _bfd_stringtab_free (stt);
6661       return FALSE;
6662     }
6663   symtab_hdr->contents = outbound_syms;
6664
6665   outbound_shndx = NULL;
6666   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6667   if (symtab_shndx_hdr->sh_name != 0)
6668     {
6669       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6670       outbound_shndx =  (bfd_byte *)
6671           bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
6672       if (outbound_shndx == NULL)
6673         {
6674           _bfd_stringtab_free (stt);
6675           return FALSE;
6676         }
6677
6678       symtab_shndx_hdr->contents = outbound_shndx;
6679       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6680       symtab_shndx_hdr->sh_size = amt;
6681       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6682       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6683     }
6684
6685   /* Now generate the data (for "contents").  */
6686   {
6687     /* Fill in zeroth symbol and swap it out.  */
6688     Elf_Internal_Sym sym;
6689     sym.st_name = 0;
6690     sym.st_value = 0;
6691     sym.st_size = 0;
6692     sym.st_info = 0;
6693     sym.st_other = 0;
6694     sym.st_shndx = SHN_UNDEF;
6695     sym.st_target_internal = 0;
6696     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6697     outbound_syms += bed->s->sizeof_sym;
6698     if (outbound_shndx != NULL)
6699       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6700   }
6701
6702   name_local_sections
6703     = (bed->elf_backend_name_local_section_symbols
6704        && bed->elf_backend_name_local_section_symbols (abfd));
6705
6706   syms = bfd_get_outsymbols (abfd);
6707   for (idx = 0; idx < symcount; idx++)
6708     {
6709       Elf_Internal_Sym sym;
6710       bfd_vma value = syms[idx]->value;
6711       elf_symbol_type *type_ptr;
6712       flagword flags = syms[idx]->flags;
6713       int type;
6714
6715       if (!name_local_sections
6716           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6717         {
6718           /* Local section symbols have no name.  */
6719           sym.st_name = 0;
6720         }
6721       else
6722         {
6723           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6724                                                             syms[idx]->name,
6725                                                             TRUE, FALSE);
6726           if (sym.st_name == (unsigned long) -1)
6727             {
6728               _bfd_stringtab_free (stt);
6729               return FALSE;
6730             }
6731         }
6732
6733       type_ptr = elf_symbol_from (abfd, syms[idx]);
6734
6735       if ((flags & BSF_SECTION_SYM) == 0
6736           && bfd_is_com_section (syms[idx]->section))
6737         {
6738           /* ELF common symbols put the alignment into the `value' field,
6739              and the size into the `size' field.  This is backwards from
6740              how BFD handles it, so reverse it here.  */
6741           sym.st_size = value;
6742           if (type_ptr == NULL
6743               || type_ptr->internal_elf_sym.st_value == 0)
6744             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6745           else
6746             sym.st_value = type_ptr->internal_elf_sym.st_value;
6747           sym.st_shndx = _bfd_elf_section_from_bfd_section
6748             (abfd, syms[idx]->section);
6749         }
6750       else
6751         {
6752           asection *sec = syms[idx]->section;
6753           unsigned int shndx;
6754
6755           if (sec->output_section)
6756             {
6757               value += sec->output_offset;
6758               sec = sec->output_section;
6759             }
6760
6761           /* Don't add in the section vma for relocatable output.  */
6762           if (! relocatable_p)
6763             value += sec->vma;
6764           sym.st_value = value;
6765           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6766
6767           if (bfd_is_abs_section (sec)
6768               && type_ptr != NULL
6769               && type_ptr->internal_elf_sym.st_shndx != 0)
6770             {
6771               /* This symbol is in a real ELF section which we did
6772                  not create as a BFD section.  Undo the mapping done
6773                  by copy_private_symbol_data.  */
6774               shndx = type_ptr->internal_elf_sym.st_shndx;
6775               switch (shndx)
6776                 {
6777                 case MAP_ONESYMTAB:
6778                   shndx = elf_onesymtab (abfd);
6779                   break;
6780                 case MAP_DYNSYMTAB:
6781                   shndx = elf_dynsymtab (abfd);
6782                   break;
6783                 case MAP_STRTAB:
6784                   shndx = elf_tdata (abfd)->strtab_section;
6785                   break;
6786                 case MAP_SHSTRTAB:
6787                   shndx = elf_tdata (abfd)->shstrtab_section;
6788                   break;
6789                 case MAP_SYM_SHNDX:
6790                   shndx = elf_tdata (abfd)->symtab_shndx_section;
6791                   break;
6792                 default:
6793                   break;
6794                 }
6795             }
6796           else
6797             {
6798               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6799
6800               if (shndx == SHN_BAD)
6801                 {
6802                   asection *sec2;
6803
6804                   /* Writing this would be a hell of a lot easier if
6805                      we had some decent documentation on bfd, and
6806                      knew what to expect of the library, and what to
6807                      demand of applications.  For example, it
6808                      appears that `objcopy' might not set the
6809                      section of a symbol to be a section that is
6810                      actually in the output file.  */
6811                   sec2 = bfd_get_section_by_name (abfd, sec->name);
6812                   if (sec2 == NULL)
6813                     {
6814                       _bfd_error_handler (_("\
6815 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6816                                           syms[idx]->name ? syms[idx]->name : "<Local sym>",
6817                                           sec->name);
6818                       bfd_set_error (bfd_error_invalid_operation);
6819                       _bfd_stringtab_free (stt);
6820                       return FALSE;
6821                     }
6822
6823                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6824                   BFD_ASSERT (shndx != SHN_BAD);
6825                 }
6826             }
6827
6828           sym.st_shndx = shndx;
6829         }
6830
6831       if ((flags & BSF_THREAD_LOCAL) != 0)
6832         type = STT_TLS;
6833       else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
6834         type = STT_GNU_IFUNC;
6835       else if ((flags & BSF_FUNCTION) != 0)
6836         type = STT_FUNC;
6837       else if ((flags & BSF_OBJECT) != 0)
6838         type = STT_OBJECT;
6839       else if ((flags & BSF_RELC) != 0)
6840         type = STT_RELC;
6841       else if ((flags & BSF_SRELC) != 0)
6842         type = STT_SRELC;
6843       else
6844         type = STT_NOTYPE;
6845
6846       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6847         type = STT_TLS;
6848
6849       /* Processor-specific types.  */
6850       if (type_ptr != NULL
6851           && bed->elf_backend_get_symbol_type)
6852         type = ((*bed->elf_backend_get_symbol_type)
6853                 (&type_ptr->internal_elf_sym, type));
6854
6855       if (flags & BSF_SECTION_SYM)
6856         {
6857           if (flags & BSF_GLOBAL)
6858             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6859           else
6860             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6861         }
6862       else if (bfd_is_com_section (syms[idx]->section))
6863         {
6864 #ifdef USE_STT_COMMON
6865           if (type == STT_OBJECT)
6866             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6867           else
6868 #endif
6869             sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6870         }
6871       else if (bfd_is_und_section (syms[idx]->section))
6872         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6873                                     ? STB_WEAK
6874                                     : STB_GLOBAL),
6875                                    type);
6876       else if (flags & BSF_FILE)
6877         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6878       else
6879         {
6880           int bind = STB_LOCAL;
6881
6882           if (flags & BSF_LOCAL)
6883             bind = STB_LOCAL;
6884           else if (flags & BSF_GNU_UNIQUE)
6885             bind = STB_GNU_UNIQUE;
6886           else if (flags & BSF_WEAK)
6887             bind = STB_WEAK;
6888           else if (flags & BSF_GLOBAL)
6889             bind = STB_GLOBAL;
6890
6891           sym.st_info = ELF_ST_INFO (bind, type);
6892         }
6893
6894       if (type_ptr != NULL)
6895         {
6896           sym.st_other = type_ptr->internal_elf_sym.st_other;
6897           sym.st_target_internal
6898             = type_ptr->internal_elf_sym.st_target_internal;
6899         }
6900       else
6901         {
6902           sym.st_other = 0;
6903           sym.st_target_internal = 0;
6904         }
6905
6906       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6907       outbound_syms += bed->s->sizeof_sym;
6908       if (outbound_shndx != NULL)
6909         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6910     }
6911
6912   *sttp = stt;
6913   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6914   symstrtab_hdr->sh_type = SHT_STRTAB;
6915
6916   symstrtab_hdr->sh_flags = 0;
6917   symstrtab_hdr->sh_addr = 0;
6918   symstrtab_hdr->sh_entsize = 0;
6919   symstrtab_hdr->sh_link = 0;
6920   symstrtab_hdr->sh_info = 0;
6921   symstrtab_hdr->sh_addralign = 1;
6922
6923   return TRUE;
6924 }
6925
6926 /* Return the number of bytes required to hold the symtab vector.
6927
6928    Note that we base it on the count plus 1, since we will null terminate
6929    the vector allocated based on this size.  However, the ELF symbol table
6930    always has a dummy entry as symbol #0, so it ends up even.  */
6931
6932 long
6933 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6934 {
6935   long symcount;
6936   long symtab_size;
6937   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6938
6939   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6940   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6941   if (symcount > 0)
6942     symtab_size -= sizeof (asymbol *);
6943
6944   return symtab_size;
6945 }
6946
6947 long
6948 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6949 {
6950   long symcount;
6951   long symtab_size;
6952   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6953
6954   if (elf_dynsymtab (abfd) == 0)
6955     {
6956       bfd_set_error (bfd_error_invalid_operation);
6957       return -1;
6958     }
6959
6960   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6961   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6962   if (symcount > 0)
6963     symtab_size -= sizeof (asymbol *);
6964
6965   return symtab_size;
6966 }
6967
6968 long
6969 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6970                                 sec_ptr asect)
6971 {
6972   return (asect->reloc_count + 1) * sizeof (arelent *);
6973 }
6974
6975 /* Canonicalize the relocs.  */
6976
6977 long
6978 _bfd_elf_canonicalize_reloc (bfd *abfd,
6979                              sec_ptr section,
6980                              arelent **relptr,
6981                              asymbol **symbols)
6982 {
6983   arelent *tblptr;
6984   unsigned int i;
6985   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6986
6987   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6988     return -1;
6989
6990   tblptr = section->relocation;
6991   for (i = 0; i < section->reloc_count; i++)
6992     *relptr++ = tblptr++;
6993
6994   *relptr = NULL;
6995
6996   return section->reloc_count;
6997 }
6998
6999 long
7000 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
7001 {
7002   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7003   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
7004
7005   if (symcount >= 0)
7006     bfd_get_symcount (abfd) = symcount;
7007   return symcount;
7008 }
7009
7010 long
7011 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
7012                                       asymbol **allocation)
7013 {
7014   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7015   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
7016
7017   if (symcount >= 0)
7018     bfd_get_dynamic_symcount (abfd) = symcount;
7019   return symcount;
7020 }
7021
7022 /* Return the size required for the dynamic reloc entries.  Any loadable
7023    section that was actually installed in the BFD, and has type SHT_REL
7024    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
7025    dynamic reloc section.  */
7026
7027 long
7028 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
7029 {
7030   long ret;
7031   asection *s;
7032
7033   if (elf_dynsymtab (abfd) == 0)
7034     {
7035       bfd_set_error (bfd_error_invalid_operation);
7036       return -1;
7037     }
7038
7039   ret = sizeof (arelent *);
7040   for (s = abfd->sections; s != NULL; s = s->next)
7041     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
7042         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
7043             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
7044       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
7045               * sizeof (arelent *));
7046
7047   return ret;
7048 }
7049
7050 /* Canonicalize the dynamic relocation entries.  Note that we return the
7051    dynamic relocations as a single block, although they are actually
7052    associated with particular sections; the interface, which was
7053    designed for SunOS style shared libraries, expects that there is only
7054    one set of dynamic relocs.  Any loadable section that was actually
7055    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
7056    dynamic symbol table, is considered to be a dynamic reloc section.  */
7057
7058 long
7059 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
7060                                      arelent **storage,
7061                                      asymbol **syms)
7062 {
7063   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
7064   asection *s;
7065   long ret;
7066
7067   if (elf_dynsymtab (abfd) == 0)
7068     {
7069       bfd_set_error (bfd_error_invalid_operation);
7070       return -1;
7071     }
7072
7073   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
7074   ret = 0;
7075   for (s = abfd->sections; s != NULL; s = s->next)
7076     {
7077       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
7078           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
7079               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
7080         {
7081           arelent *p;
7082           long count, i;
7083
7084           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
7085             return -1;
7086           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
7087           p = s->relocation;
7088           for (i = 0; i < count; i++)
7089             *storage++ = p++;
7090           ret += count;
7091         }
7092     }
7093
7094   *storage = NULL;
7095
7096   return ret;
7097 }
7098 \f
7099 /* Read in the version information.  */
7100
7101 bfd_boolean
7102 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
7103 {
7104   bfd_byte *contents = NULL;
7105   unsigned int freeidx = 0;
7106
7107   if (elf_dynverref (abfd) != 0)
7108     {
7109       Elf_Internal_Shdr *hdr;
7110       Elf_External_Verneed *everneed;
7111       Elf_Internal_Verneed *iverneed;
7112       unsigned int i;
7113       bfd_byte *contents_end;
7114
7115       hdr = &elf_tdata (abfd)->dynverref_hdr;
7116
7117       elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
7118           bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
7119       if (elf_tdata (abfd)->verref == NULL)
7120         goto error_return;
7121
7122       elf_tdata (abfd)->cverrefs = hdr->sh_info;
7123
7124       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
7125       if (contents == NULL)
7126         {
7127 error_return_verref:
7128           elf_tdata (abfd)->verref = NULL;
7129           elf_tdata (abfd)->cverrefs = 0;
7130           goto error_return;
7131         }
7132       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7133           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
7134         goto error_return_verref;
7135
7136       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
7137         goto error_return_verref;
7138
7139       BFD_ASSERT (sizeof (Elf_External_Verneed)
7140                   == sizeof (Elf_External_Vernaux));
7141       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
7142       everneed = (Elf_External_Verneed *) contents;
7143       iverneed = elf_tdata (abfd)->verref;
7144       for (i = 0; i < hdr->sh_info; i++, iverneed++)
7145         {
7146           Elf_External_Vernaux *evernaux;
7147           Elf_Internal_Vernaux *ivernaux;
7148           unsigned int j;
7149
7150           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
7151
7152           iverneed->vn_bfd = abfd;
7153
7154           iverneed->vn_filename =
7155             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7156                                              iverneed->vn_file);
7157           if (iverneed->vn_filename == NULL)
7158             goto error_return_verref;
7159
7160           if (iverneed->vn_cnt == 0)
7161             iverneed->vn_auxptr = NULL;
7162           else
7163             {
7164               iverneed->vn_auxptr = (struct elf_internal_vernaux *)
7165                   bfd_alloc2 (abfd, iverneed->vn_cnt,
7166                               sizeof (Elf_Internal_Vernaux));
7167               if (iverneed->vn_auxptr == NULL)
7168                 goto error_return_verref;
7169             }
7170
7171           if (iverneed->vn_aux
7172               > (size_t) (contents_end - (bfd_byte *) everneed))
7173             goto error_return_verref;
7174
7175           evernaux = ((Elf_External_Vernaux *)
7176                       ((bfd_byte *) everneed + iverneed->vn_aux));
7177           ivernaux = iverneed->vn_auxptr;
7178           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
7179             {
7180               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
7181
7182               ivernaux->vna_nodename =
7183                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7184                                                  ivernaux->vna_name);
7185               if (ivernaux->vna_nodename == NULL)
7186                 goto error_return_verref;
7187
7188               if (j + 1 < iverneed->vn_cnt)
7189                 ivernaux->vna_nextptr = ivernaux + 1;
7190               else
7191                 ivernaux->vna_nextptr = NULL;
7192
7193               if (ivernaux->vna_next
7194                   > (size_t) (contents_end - (bfd_byte *) evernaux))
7195                 goto error_return_verref;
7196
7197               evernaux = ((Elf_External_Vernaux *)
7198                           ((bfd_byte *) evernaux + ivernaux->vna_next));
7199
7200               if (ivernaux->vna_other > freeidx)
7201                 freeidx = ivernaux->vna_other;
7202             }
7203
7204           if (i + 1 < hdr->sh_info)
7205             iverneed->vn_nextref = iverneed + 1;
7206           else
7207             iverneed->vn_nextref = NULL;
7208
7209           if (iverneed->vn_next
7210               > (size_t) (contents_end - (bfd_byte *) everneed))
7211             goto error_return_verref;
7212
7213           everneed = ((Elf_External_Verneed *)
7214                       ((bfd_byte *) everneed + iverneed->vn_next));
7215         }
7216
7217       free (contents);
7218       contents = NULL;
7219     }
7220
7221   if (elf_dynverdef (abfd) != 0)
7222     {
7223       Elf_Internal_Shdr *hdr;
7224       Elf_External_Verdef *everdef;
7225       Elf_Internal_Verdef *iverdef;
7226       Elf_Internal_Verdef *iverdefarr;
7227       Elf_Internal_Verdef iverdefmem;
7228       unsigned int i;
7229       unsigned int maxidx;
7230       bfd_byte *contents_end_def, *contents_end_aux;
7231
7232       hdr = &elf_tdata (abfd)->dynverdef_hdr;
7233
7234       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
7235       if (contents == NULL)
7236         goto error_return;
7237       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7238           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
7239         goto error_return;
7240
7241       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
7242         goto error_return;
7243
7244       BFD_ASSERT (sizeof (Elf_External_Verdef)
7245                   >= sizeof (Elf_External_Verdaux));
7246       contents_end_def = contents + hdr->sh_size
7247                          - sizeof (Elf_External_Verdef);
7248       contents_end_aux = contents + hdr->sh_size
7249                          - sizeof (Elf_External_Verdaux);
7250
7251       /* We know the number of entries in the section but not the maximum
7252          index.  Therefore we have to run through all entries and find
7253          the maximum.  */
7254       everdef = (Elf_External_Verdef *) contents;
7255       maxidx = 0;
7256       for (i = 0; i < hdr->sh_info; ++i)
7257         {
7258           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7259
7260           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
7261             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
7262
7263           if (iverdefmem.vd_next
7264               > (size_t) (contents_end_def - (bfd_byte *) everdef))
7265             goto error_return;
7266
7267           everdef = ((Elf_External_Verdef *)
7268                      ((bfd_byte *) everdef + iverdefmem.vd_next));
7269         }
7270
7271       if (default_imported_symver)
7272         {
7273           if (freeidx > maxidx)
7274             maxidx = ++freeidx;
7275           else
7276             freeidx = ++maxidx;
7277         }
7278       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7279           bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
7280       if (elf_tdata (abfd)->verdef == NULL)
7281         goto error_return;
7282
7283       elf_tdata (abfd)->cverdefs = maxidx;
7284
7285       everdef = (Elf_External_Verdef *) contents;
7286       iverdefarr = elf_tdata (abfd)->verdef;
7287       for (i = 0; i < hdr->sh_info; i++)
7288         {
7289           Elf_External_Verdaux *everdaux;
7290           Elf_Internal_Verdaux *iverdaux;
7291           unsigned int j;
7292
7293           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7294
7295           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
7296             {
7297 error_return_verdef:
7298               elf_tdata (abfd)->verdef = NULL;
7299               elf_tdata (abfd)->cverdefs = 0;
7300               goto error_return;
7301             }
7302
7303           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
7304           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
7305
7306           iverdef->vd_bfd = abfd;
7307
7308           if (iverdef->vd_cnt == 0)
7309             iverdef->vd_auxptr = NULL;
7310           else
7311             {
7312               iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7313                   bfd_alloc2 (abfd, iverdef->vd_cnt,
7314                               sizeof (Elf_Internal_Verdaux));
7315               if (iverdef->vd_auxptr == NULL)
7316                 goto error_return_verdef;
7317             }
7318
7319           if (iverdef->vd_aux
7320               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
7321             goto error_return_verdef;
7322
7323           everdaux = ((Elf_External_Verdaux *)
7324                       ((bfd_byte *) everdef + iverdef->vd_aux));
7325           iverdaux = iverdef->vd_auxptr;
7326           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
7327             {
7328               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
7329
7330               iverdaux->vda_nodename =
7331                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7332                                                  iverdaux->vda_name);
7333               if (iverdaux->vda_nodename == NULL)
7334                 goto error_return_verdef;
7335
7336               if (j + 1 < iverdef->vd_cnt)
7337                 iverdaux->vda_nextptr = iverdaux + 1;
7338               else
7339                 iverdaux->vda_nextptr = NULL;
7340
7341               if (iverdaux->vda_next
7342                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
7343                 goto error_return_verdef;
7344
7345               everdaux = ((Elf_External_Verdaux *)
7346                           ((bfd_byte *) everdaux + iverdaux->vda_next));
7347             }
7348
7349           if (iverdef->vd_cnt)
7350             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
7351
7352           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
7353             iverdef->vd_nextdef = iverdef + 1;
7354           else
7355             iverdef->vd_nextdef = NULL;
7356
7357           everdef = ((Elf_External_Verdef *)
7358                      ((bfd_byte *) everdef + iverdef->vd_next));
7359         }
7360
7361       free (contents);
7362       contents = NULL;
7363     }
7364   else if (default_imported_symver)
7365     {
7366       if (freeidx < 3)
7367         freeidx = 3;
7368       else
7369         freeidx++;
7370
7371       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7372           bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
7373       if (elf_tdata (abfd)->verdef == NULL)
7374         goto error_return;
7375
7376       elf_tdata (abfd)->cverdefs = freeidx;
7377     }
7378
7379   /* Create a default version based on the soname.  */
7380   if (default_imported_symver)
7381     {
7382       Elf_Internal_Verdef *iverdef;
7383       Elf_Internal_Verdaux *iverdaux;
7384
7385       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
7386
7387       iverdef->vd_version = VER_DEF_CURRENT;
7388       iverdef->vd_flags = 0;
7389       iverdef->vd_ndx = freeidx;
7390       iverdef->vd_cnt = 1;
7391
7392       iverdef->vd_bfd = abfd;
7393
7394       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
7395       if (iverdef->vd_nodename == NULL)
7396         goto error_return_verdef;
7397       iverdef->vd_nextdef = NULL;
7398       iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7399           bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
7400       if (iverdef->vd_auxptr == NULL)
7401         goto error_return_verdef;
7402
7403       iverdaux = iverdef->vd_auxptr;
7404       iverdaux->vda_nodename = iverdef->vd_nodename;
7405       iverdaux->vda_nextptr = NULL;
7406     }
7407
7408   return TRUE;
7409
7410  error_return:
7411   if (contents != NULL)
7412     free (contents);
7413   return FALSE;
7414 }
7415 \f
7416 asymbol *
7417 _bfd_elf_make_empty_symbol (bfd *abfd)
7418 {
7419   elf_symbol_type *newsym;
7420   bfd_size_type amt = sizeof (elf_symbol_type);
7421
7422   newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
7423   if (!newsym)
7424     return NULL;
7425   else
7426     {
7427       newsym->symbol.the_bfd = abfd;
7428       return &newsym->symbol;
7429     }
7430 }
7431
7432 void
7433 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7434                           asymbol *symbol,
7435                           symbol_info *ret)
7436 {
7437   bfd_symbol_info (symbol, ret);
7438 }
7439
7440 /* Return whether a symbol name implies a local symbol.  Most targets
7441    use this function for the is_local_label_name entry point, but some
7442    override it.  */
7443
7444 bfd_boolean
7445 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7446                               const char *name)
7447 {
7448   /* Normal local symbols start with ``.L''.  */
7449   if (name[0] == '.' && name[1] == 'L')
7450     return TRUE;
7451
7452   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7453      DWARF debugging symbols starting with ``..''.  */
7454   if (name[0] == '.' && name[1] == '.')
7455     return TRUE;
7456
7457   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7458      emitting DWARF debugging output.  I suspect this is actually a
7459      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7460      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7461      underscore to be emitted on some ELF targets).  For ease of use,
7462      we treat such symbols as local.  */
7463   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
7464     return TRUE;
7465
7466   return FALSE;
7467 }
7468
7469 alent *
7470 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7471                      asymbol *symbol ATTRIBUTE_UNUSED)
7472 {
7473   abort ();
7474   return NULL;
7475 }
7476
7477 bfd_boolean
7478 _bfd_elf_set_arch_mach (bfd *abfd,
7479                         enum bfd_architecture arch,
7480                         unsigned long machine)
7481 {
7482   /* If this isn't the right architecture for this backend, and this
7483      isn't the generic backend, fail.  */
7484   if (arch != get_elf_backend_data (abfd)->arch
7485       && arch != bfd_arch_unknown
7486       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
7487     return FALSE;
7488
7489   return bfd_default_set_arch_mach (abfd, arch, machine);
7490 }
7491
7492 /* Find the function to a particular section and offset,
7493    for error reporting.  */
7494
7495 static bfd_boolean
7496 elf_find_function (bfd *abfd,
7497                    asection *section,
7498                    asymbol **symbols,
7499                    bfd_vma offset,
7500                    const char **filename_ptr,
7501                    const char **functionname_ptr)
7502 {
7503   static asection *last_section;
7504   static asymbol *func;
7505   static const char *filename;
7506   static bfd_size_type func_size;
7507
7508   if (symbols == NULL)
7509     return FALSE;
7510
7511   if (last_section != section
7512       || func == NULL
7513       || offset < func->value
7514       || offset >= func->value + func_size)
7515     {
7516       asymbol *file;
7517       bfd_vma low_func;
7518       asymbol **p;
7519       /* ??? Given multiple file symbols, it is impossible to reliably
7520          choose the right file name for global symbols.  File symbols are
7521          local symbols, and thus all file symbols must sort before any
7522          global symbols.  The ELF spec may be interpreted to say that a
7523          file symbol must sort before other local symbols, but currently
7524          ld -r doesn't do this.  So, for ld -r output, it is possible to
7525          make a better choice of file name for local symbols by ignoring
7526          file symbols appearing after a given local symbol.  */
7527       enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7528       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7529
7530       filename = NULL;
7531       func = NULL;
7532       file = NULL;
7533       low_func = 0;
7534       state = nothing_seen;
7535       func_size = 0;
7536       last_section = section;
7537
7538       for (p = symbols; *p != NULL; p++)
7539         {
7540           asymbol *sym = *p;
7541           bfd_vma code_off;
7542           bfd_size_type size;
7543
7544           if ((sym->flags & BSF_FILE) != 0)
7545             {
7546               file = sym;
7547               if (state == symbol_seen)
7548                 state = file_after_symbol_seen;
7549               continue;
7550             }
7551
7552           size = bed->maybe_function_sym (sym, section, &code_off);
7553           if (size != 0
7554               && code_off <= offset
7555               && (code_off > low_func
7556                   || (code_off == low_func
7557                       && size > func_size)))
7558             {
7559               func = sym;
7560               func_size = size;
7561               low_func = code_off;
7562               filename = NULL;
7563               if (file != NULL
7564                   && ((sym->flags & BSF_LOCAL) != 0
7565                       || state != file_after_symbol_seen))
7566                 filename = bfd_asymbol_name (file);
7567             }
7568           if (state == nothing_seen)
7569             state = symbol_seen;
7570         }
7571     }
7572
7573   if (func == NULL)
7574     return FALSE;
7575
7576   if (filename_ptr)
7577     *filename_ptr = filename;
7578   if (functionname_ptr)
7579     *functionname_ptr = bfd_asymbol_name (func);
7580
7581   return TRUE;
7582 }
7583
7584 /* Find the nearest line to a particular section and offset,
7585    for error reporting.  */
7586
7587 bfd_boolean
7588 _bfd_elf_find_nearest_line (bfd *abfd,
7589                             asection *section,
7590                             asymbol **symbols,
7591                             bfd_vma offset,
7592                             const char **filename_ptr,
7593                             const char **functionname_ptr,
7594                             unsigned int *line_ptr)
7595 {
7596   return _bfd_elf_find_nearest_line_discriminator (abfd, section, symbols,
7597                                                    offset, filename_ptr,
7598                                                    functionname_ptr,
7599                                                    line_ptr,
7600                                                    NULL);
7601 }
7602
7603 bfd_boolean
7604 _bfd_elf_find_nearest_line_discriminator (bfd *abfd,
7605                                           asection *section,
7606                                           asymbol **symbols,
7607                                           bfd_vma offset,
7608                                           const char **filename_ptr,
7609                                           const char **functionname_ptr,
7610                                           unsigned int *line_ptr,
7611                                           unsigned int *discriminator_ptr)
7612 {
7613   bfd_boolean found;
7614
7615   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7616                                      filename_ptr, functionname_ptr,
7617                                      line_ptr))
7618     {
7619       if (!*functionname_ptr)
7620         elf_find_function (abfd, section, symbols, offset,
7621                            *filename_ptr ? NULL : filename_ptr,
7622                            functionname_ptr);
7623
7624       return TRUE;
7625     }
7626
7627   if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
7628                                      section, symbols, offset,
7629                                      filename_ptr, functionname_ptr,
7630                                      line_ptr, discriminator_ptr, 0,
7631                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7632     {
7633       if (!*functionname_ptr)
7634         elf_find_function (abfd, section, symbols, offset,
7635                            *filename_ptr ? NULL : filename_ptr,
7636                            functionname_ptr);
7637
7638       return TRUE;
7639     }
7640
7641   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7642                                              &found, filename_ptr,
7643                                              functionname_ptr, line_ptr,
7644                                              &elf_tdata (abfd)->line_info))
7645     return FALSE;
7646   if (found && (*functionname_ptr || *line_ptr))
7647     return TRUE;
7648
7649   if (symbols == NULL)
7650     return FALSE;
7651
7652   if (! elf_find_function (abfd, section, symbols, offset,
7653                            filename_ptr, functionname_ptr))
7654     return FALSE;
7655
7656   *line_ptr = 0;
7657   return TRUE;
7658 }
7659
7660 /* Find the line for a symbol.  */
7661
7662 bfd_boolean
7663 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7664                     const char **filename_ptr, unsigned int *line_ptr)
7665 {
7666   return _bfd_elf_find_line_discriminator (abfd, symbols, symbol,
7667                                            filename_ptr, line_ptr,
7668                                            NULL);
7669 }
7670
7671 bfd_boolean
7672 _bfd_elf_find_line_discriminator (bfd *abfd, asymbol **symbols, asymbol *symbol,
7673                                   const char **filename_ptr,
7674                                   unsigned int *line_ptr,
7675                                   unsigned int *discriminator_ptr)
7676 {
7677   return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7678                                 filename_ptr, line_ptr, discriminator_ptr, 0,
7679                                 &elf_tdata (abfd)->dwarf2_find_line_info);
7680 }
7681
7682 /* After a call to bfd_find_nearest_line, successive calls to
7683    bfd_find_inliner_info can be used to get source information about
7684    each level of function inlining that terminated at the address
7685    passed to bfd_find_nearest_line.  Currently this is only supported
7686    for DWARF2 with appropriate DWARF3 extensions. */
7687
7688 bfd_boolean
7689 _bfd_elf_find_inliner_info (bfd *abfd,
7690                             const char **filename_ptr,
7691                             const char **functionname_ptr,
7692                             unsigned int *line_ptr)
7693 {
7694   bfd_boolean found;
7695   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7696                                          functionname_ptr, line_ptr,
7697                                          & elf_tdata (abfd)->dwarf2_find_line_info);
7698   return found;
7699 }
7700
7701 int
7702 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7703 {
7704   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7705   int ret = bed->s->sizeof_ehdr;
7706
7707   if (!info->relocatable)
7708     {
7709       bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7710
7711       if (phdr_size == (bfd_size_type) -1)
7712         {
7713           struct elf_segment_map *m;
7714
7715           phdr_size = 0;
7716           for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7717             phdr_size += bed->s->sizeof_phdr;
7718
7719           if (phdr_size == 0)
7720             phdr_size = get_program_header_size (abfd, info);
7721         }
7722
7723       elf_tdata (abfd)->program_header_size = phdr_size;
7724       ret += phdr_size;
7725     }
7726
7727   return ret;
7728 }
7729
7730 bfd_boolean
7731 _bfd_elf_set_section_contents (bfd *abfd,
7732                                sec_ptr section,
7733                                const void *location,
7734                                file_ptr offset,
7735                                bfd_size_type count)
7736 {
7737   Elf_Internal_Shdr *hdr;
7738   bfd_signed_vma pos;
7739
7740   if (! abfd->output_has_begun
7741       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7742     return FALSE;
7743
7744   hdr = &elf_section_data (section)->this_hdr;
7745   pos = hdr->sh_offset + offset;
7746   if (bfd_seek (abfd, pos, SEEK_SET) != 0
7747       || bfd_bwrite (location, count, abfd) != count)
7748     return FALSE;
7749
7750   return TRUE;
7751 }
7752
7753 void
7754 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7755                            arelent *cache_ptr ATTRIBUTE_UNUSED,
7756                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7757 {
7758   abort ();
7759 }
7760
7761 /* Try to convert a non-ELF reloc into an ELF one.  */
7762
7763 bfd_boolean
7764 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7765 {
7766   /* Check whether we really have an ELF howto.  */
7767
7768   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7769     {
7770       bfd_reloc_code_real_type code;
7771       reloc_howto_type *howto;
7772
7773       /* Alien reloc: Try to determine its type to replace it with an
7774          equivalent ELF reloc.  */
7775
7776       if (areloc->howto->pc_relative)
7777         {
7778           switch (areloc->howto->bitsize)
7779             {
7780             case 8:
7781               code = BFD_RELOC_8_PCREL;
7782               break;
7783             case 12:
7784               code = BFD_RELOC_12_PCREL;
7785               break;
7786             case 16:
7787               code = BFD_RELOC_16_PCREL;
7788               break;
7789             case 24:
7790               code = BFD_RELOC_24_PCREL;
7791               break;
7792             case 32:
7793               code = BFD_RELOC_32_PCREL;
7794               break;
7795             case 64:
7796               code = BFD_RELOC_64_PCREL;
7797               break;
7798             default:
7799               goto fail;
7800             }
7801
7802           howto = bfd_reloc_type_lookup (abfd, code);
7803
7804           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7805             {
7806               if (howto->pcrel_offset)
7807                 areloc->addend += areloc->address;
7808               else
7809                 areloc->addend -= areloc->address; /* addend is unsigned!! */
7810             }
7811         }
7812       else
7813         {
7814           switch (areloc->howto->bitsize)
7815             {
7816             case 8:
7817               code = BFD_RELOC_8;
7818               break;
7819             case 14:
7820               code = BFD_RELOC_14;
7821               break;
7822             case 16:
7823               code = BFD_RELOC_16;
7824               break;
7825             case 26:
7826               code = BFD_RELOC_26;
7827               break;
7828             case 32:
7829               code = BFD_RELOC_32;
7830               break;
7831             case 64:
7832               code = BFD_RELOC_64;
7833               break;
7834             default:
7835               goto fail;
7836             }
7837
7838           howto = bfd_reloc_type_lookup (abfd, code);
7839         }
7840
7841       if (howto)
7842         areloc->howto = howto;
7843       else
7844         goto fail;
7845     }
7846
7847   return TRUE;
7848
7849  fail:
7850   (*_bfd_error_handler)
7851     (_("%B: unsupported relocation type %s"),
7852      abfd, areloc->howto->name);
7853   bfd_set_error (bfd_error_bad_value);
7854   return FALSE;
7855 }
7856
7857 bfd_boolean
7858 _bfd_elf_close_and_cleanup (bfd *abfd)
7859 {
7860   struct elf_obj_tdata *tdata = elf_tdata (abfd);
7861   if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
7862     {
7863       if (elf_shstrtab (abfd) != NULL)
7864         _bfd_elf_strtab_free (elf_shstrtab (abfd));
7865       _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
7866     }
7867
7868   return _bfd_generic_close_and_cleanup (abfd);
7869 }
7870
7871 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7872    in the relocation's offset.  Thus we cannot allow any sort of sanity
7873    range-checking to interfere.  There is nothing else to do in processing
7874    this reloc.  */
7875
7876 bfd_reloc_status_type
7877 _bfd_elf_rel_vtable_reloc_fn
7878   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7879    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7880    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7881    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7882 {
7883   return bfd_reloc_ok;
7884 }
7885 \f
7886 /* Elf core file support.  Much of this only works on native
7887    toolchains, since we rely on knowing the
7888    machine-dependent procfs structure in order to pick
7889    out details about the corefile.  */
7890
7891 #ifdef HAVE_SYS_PROCFS_H
7892 /* Needed for new procfs interface on sparc-solaris.  */
7893 # define _STRUCTURED_PROC 1
7894 # include <sys/procfs.h>
7895 #endif
7896
7897 /* Return a PID that identifies a "thread" for threaded cores, or the
7898    PID of the main process for non-threaded cores.  */
7899
7900 static int
7901 elfcore_make_pid (bfd *abfd)
7902 {
7903   int pid;
7904
7905   pid = elf_tdata (abfd)->core_lwpid;
7906   if (pid == 0)
7907     pid = elf_tdata (abfd)->core_pid;
7908
7909   return pid;
7910 }
7911
7912 /* If there isn't a section called NAME, make one, using
7913    data from SECT.  Note, this function will generate a
7914    reference to NAME, so you shouldn't deallocate or
7915    overwrite it.  */
7916
7917 static bfd_boolean
7918 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7919 {
7920   asection *sect2;
7921
7922   if (bfd_get_section_by_name (abfd, name) != NULL)
7923     return TRUE;
7924
7925   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7926   if (sect2 == NULL)
7927     return FALSE;
7928
7929   sect2->size = sect->size;
7930   sect2->filepos = sect->filepos;
7931   sect2->alignment_power = sect->alignment_power;
7932   return TRUE;
7933 }
7934
7935 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
7936    actually creates up to two pseudosections:
7937    - For the single-threaded case, a section named NAME, unless
7938      such a section already exists.
7939    - For the multi-threaded case, a section named "NAME/PID", where
7940      PID is elfcore_make_pid (abfd).
7941    Both pseudosections have identical contents. */
7942 bfd_boolean
7943 _bfd_elfcore_make_pseudosection (bfd *abfd,
7944                                  char *name,
7945                                  size_t size,
7946                                  ufile_ptr filepos)
7947 {
7948   char buf[100];
7949   char *threaded_name;
7950   size_t len;
7951   asection *sect;
7952
7953   /* Build the section name.  */
7954
7955   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7956   len = strlen (buf) + 1;
7957   threaded_name = (char *) bfd_alloc (abfd, len);
7958   if (threaded_name == NULL)
7959     return FALSE;
7960   memcpy (threaded_name, buf, len);
7961
7962   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7963                                              SEC_HAS_CONTENTS);
7964   if (sect == NULL)
7965     return FALSE;
7966   sect->size = size;
7967   sect->filepos = filepos;
7968   sect->alignment_power = 2;
7969
7970   return elfcore_maybe_make_sect (abfd, name, sect);
7971 }
7972
7973 /* prstatus_t exists on:
7974      solaris 2.5+
7975      linux 2.[01] + glibc
7976      unixware 4.2
7977 */
7978
7979 #if defined (HAVE_PRSTATUS_T)
7980
7981 static bfd_boolean
7982 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7983 {
7984   size_t size;
7985   int offset;
7986
7987   if (note->descsz == sizeof (prstatus_t))
7988     {
7989       prstatus_t prstat;
7990
7991       size = sizeof (prstat.pr_reg);
7992       offset   = offsetof (prstatus_t, pr_reg);
7993       memcpy (&prstat, note->descdata, sizeof (prstat));
7994
7995       /* Do not overwrite the core signal if it
7996          has already been set by another thread.  */
7997       if (elf_tdata (abfd)->core_signal == 0)
7998         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7999       if (elf_tdata (abfd)->core_pid == 0)
8000         elf_tdata (abfd)->core_pid = prstat.pr_pid;
8001
8002       /* pr_who exists on:
8003          solaris 2.5+
8004          unixware 4.2
8005          pr_who doesn't exist on:
8006          linux 2.[01]
8007          */
8008 #if defined (HAVE_PRSTATUS_T_PR_WHO)
8009       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
8010 #else
8011       elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
8012 #endif
8013     }
8014 #if defined (HAVE_PRSTATUS32_T)
8015   else if (note->descsz == sizeof (prstatus32_t))
8016     {
8017       /* 64-bit host, 32-bit corefile */
8018       prstatus32_t prstat;
8019
8020       size = sizeof (prstat.pr_reg);
8021       offset   = offsetof (prstatus32_t, pr_reg);
8022       memcpy (&prstat, note->descdata, sizeof (prstat));
8023
8024       /* Do not overwrite the core signal if it
8025          has already been set by another thread.  */
8026       if (elf_tdata (abfd)->core_signal == 0)
8027         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
8028       if (elf_tdata (abfd)->core_pid == 0)
8029         elf_tdata (abfd)->core_pid = prstat.pr_pid;
8030
8031       /* pr_who exists on:
8032          solaris 2.5+
8033          unixware 4.2
8034          pr_who doesn't exist on:
8035          linux 2.[01]
8036          */
8037 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
8038       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
8039 #else
8040       elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
8041 #endif
8042     }
8043 #endif /* HAVE_PRSTATUS32_T */
8044   else
8045     {
8046       /* Fail - we don't know how to handle any other
8047          note size (ie. data object type).  */
8048       return TRUE;
8049     }
8050
8051   /* Make a ".reg/999" section and a ".reg" section.  */
8052   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
8053                                           size, note->descpos + offset);
8054 }
8055 #endif /* defined (HAVE_PRSTATUS_T) */
8056
8057 /* Create a pseudosection containing the exact contents of NOTE.  */
8058 static bfd_boolean
8059 elfcore_make_note_pseudosection (bfd *abfd,
8060                                  char *name,
8061                                  Elf_Internal_Note *note)
8062 {
8063   return _bfd_elfcore_make_pseudosection (abfd, name,
8064                                           note->descsz, note->descpos);
8065 }
8066
8067 /* There isn't a consistent prfpregset_t across platforms,
8068    but it doesn't matter, because we don't have to pick this
8069    data structure apart.  */
8070
8071 static bfd_boolean
8072 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
8073 {
8074   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8075 }
8076
8077 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
8078    type of NT_PRXFPREG.  Just include the whole note's contents
8079    literally.  */
8080
8081 static bfd_boolean
8082 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
8083 {
8084   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8085 }
8086
8087 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
8088    with a note type of NT_X86_XSTATE.  Just include the whole note's
8089    contents literally.  */
8090
8091 static bfd_boolean
8092 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
8093 {
8094   return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
8095 }
8096
8097 static bfd_boolean
8098 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
8099 {
8100   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
8101 }
8102
8103 static bfd_boolean
8104 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
8105 {
8106   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
8107 }
8108
8109 static bfd_boolean
8110 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
8111 {
8112   return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
8113 }
8114
8115 static bfd_boolean
8116 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
8117 {
8118   return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
8119 }
8120
8121 static bfd_boolean
8122 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
8123 {
8124   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
8125 }
8126
8127 static bfd_boolean
8128 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
8129 {
8130   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
8131 }
8132
8133 static bfd_boolean
8134 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
8135 {
8136   return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
8137 }
8138
8139 static bfd_boolean
8140 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
8141 {
8142   return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
8143 }
8144
8145 static bfd_boolean
8146 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
8147 {
8148   return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
8149 }
8150
8151 static bfd_boolean
8152 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
8153 {
8154   return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
8155 }
8156
8157 static bfd_boolean
8158 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
8159 {
8160   return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
8161 }
8162
8163 #if defined (HAVE_PRPSINFO_T)
8164 typedef prpsinfo_t   elfcore_psinfo_t;
8165 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
8166 typedef prpsinfo32_t elfcore_psinfo32_t;
8167 #endif
8168 #endif
8169
8170 #if defined (HAVE_PSINFO_T)
8171 typedef psinfo_t   elfcore_psinfo_t;
8172 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
8173 typedef psinfo32_t elfcore_psinfo32_t;
8174 #endif
8175 #endif
8176
8177 /* return a malloc'ed copy of a string at START which is at
8178    most MAX bytes long, possibly without a terminating '\0'.
8179    the copy will always have a terminating '\0'.  */
8180
8181 char *
8182 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
8183 {
8184   char *dups;
8185   char *end = (char *) memchr (start, '\0', max);
8186   size_t len;
8187
8188   if (end == NULL)
8189     len = max;
8190   else
8191     len = end - start;
8192
8193   dups = (char *) bfd_alloc (abfd, len + 1);
8194   if (dups == NULL)
8195     return NULL;
8196
8197   memcpy (dups, start, len);
8198   dups[len] = '\0';
8199
8200   return dups;
8201 }
8202
8203 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8204 static bfd_boolean
8205 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
8206 {
8207   if (note->descsz == sizeof (elfcore_psinfo_t))
8208     {
8209       elfcore_psinfo_t psinfo;
8210
8211       memcpy (&psinfo, note->descdata, sizeof (psinfo));
8212
8213 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
8214       elf_tdata (abfd)->core_pid = psinfo.pr_pid;
8215 #endif
8216       elf_tdata (abfd)->core_program
8217         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8218                                 sizeof (psinfo.pr_fname));
8219
8220       elf_tdata (abfd)->core_command
8221         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8222                                 sizeof (psinfo.pr_psargs));
8223     }
8224 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8225   else if (note->descsz == sizeof (elfcore_psinfo32_t))
8226     {
8227       /* 64-bit host, 32-bit corefile */
8228       elfcore_psinfo32_t psinfo;
8229
8230       memcpy (&psinfo, note->descdata, sizeof (psinfo));
8231
8232 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
8233       elf_tdata (abfd)->core_pid = psinfo.pr_pid;
8234 #endif
8235       elf_tdata (abfd)->core_program
8236         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8237                                 sizeof (psinfo.pr_fname));
8238
8239       elf_tdata (abfd)->core_command
8240         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8241                                 sizeof (psinfo.pr_psargs));
8242     }
8243 #endif
8244
8245   else
8246     {
8247       /* Fail - we don't know how to handle any other
8248          note size (ie. data object type).  */
8249       return TRUE;
8250     }
8251
8252   /* Note that for some reason, a spurious space is tacked
8253      onto the end of the args in some (at least one anyway)
8254      implementations, so strip it off if it exists.  */
8255
8256   {
8257     char *command = elf_tdata (abfd)->core_command;
8258     int n = strlen (command);
8259
8260     if (0 < n && command[n - 1] == ' ')
8261       command[n - 1] = '\0';
8262   }
8263
8264   return TRUE;
8265 }
8266 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
8267
8268 #if defined (HAVE_PSTATUS_T)
8269 static bfd_boolean
8270 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
8271 {
8272   if (note->descsz == sizeof (pstatus_t)
8273 #if defined (HAVE_PXSTATUS_T)
8274       || note->descsz == sizeof (pxstatus_t)
8275 #endif
8276       )
8277     {
8278       pstatus_t pstat;
8279
8280       memcpy (&pstat, note->descdata, sizeof (pstat));
8281
8282       elf_tdata (abfd)->core_pid = pstat.pr_pid;
8283     }
8284 #if defined (HAVE_PSTATUS32_T)
8285   else if (note->descsz == sizeof (pstatus32_t))
8286     {
8287       /* 64-bit host, 32-bit corefile */
8288       pstatus32_t pstat;
8289
8290       memcpy (&pstat, note->descdata, sizeof (pstat));
8291
8292       elf_tdata (abfd)->core_pid = pstat.pr_pid;
8293     }
8294 #endif
8295   /* Could grab some more details from the "representative"
8296      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
8297      NT_LWPSTATUS note, presumably.  */
8298
8299   return TRUE;
8300 }
8301 #endif /* defined (HAVE_PSTATUS_T) */
8302
8303 #if defined (HAVE_LWPSTATUS_T)
8304 static bfd_boolean
8305 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
8306 {
8307   lwpstatus_t lwpstat;
8308   char buf[100];
8309   char *name;
8310   size_t len;
8311   asection *sect;
8312
8313   if (note->descsz != sizeof (lwpstat)
8314 #if defined (HAVE_LWPXSTATUS_T)
8315       && note->descsz != sizeof (lwpxstatus_t)
8316 #endif
8317       )
8318     return TRUE;
8319
8320   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
8321
8322   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
8323   /* Do not overwrite the core signal if it has already been set by
8324      another thread.  */
8325   if (elf_tdata (abfd)->core_signal == 0)
8326     elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
8327
8328   /* Make a ".reg/999" section.  */
8329
8330   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
8331   len = strlen (buf) + 1;
8332   name = bfd_alloc (abfd, len);
8333   if (name == NULL)
8334     return FALSE;
8335   memcpy (name, buf, len);
8336
8337   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8338   if (sect == NULL)
8339     return FALSE;
8340
8341 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8342   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
8343   sect->filepos = note->descpos
8344     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
8345 #endif
8346
8347 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8348   sect->size = sizeof (lwpstat.pr_reg);
8349   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
8350 #endif
8351
8352   sect->alignment_power = 2;
8353
8354   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
8355     return FALSE;
8356
8357   /* Make a ".reg2/999" section */
8358
8359   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
8360   len = strlen (buf) + 1;
8361   name = bfd_alloc (abfd, len);
8362   if (name == NULL)
8363     return FALSE;
8364   memcpy (name, buf, len);
8365
8366   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8367   if (sect == NULL)
8368     return FALSE;
8369
8370 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8371   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
8372   sect->filepos = note->descpos
8373     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
8374 #endif
8375
8376 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
8377   sect->size = sizeof (lwpstat.pr_fpreg);
8378   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
8379 #endif
8380
8381   sect->alignment_power = 2;
8382
8383   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
8384 }
8385 #endif /* defined (HAVE_LWPSTATUS_T) */
8386
8387 static bfd_boolean
8388 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
8389 {
8390   char buf[30];
8391   char *name;
8392   size_t len;
8393   asection *sect;
8394   int type;
8395   int is_active_thread;
8396   bfd_vma base_addr;
8397
8398   if (note->descsz < 728)
8399     return TRUE;
8400
8401   if (! CONST_STRNEQ (note->namedata, "win32"))
8402     return TRUE;
8403
8404   type = bfd_get_32 (abfd, note->descdata);
8405
8406   switch (type)
8407     {
8408     case 1 /* NOTE_INFO_PROCESS */:
8409       /* FIXME: need to add ->core_command.  */
8410       /* process_info.pid */
8411       elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
8412       /* process_info.signal */
8413       elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
8414       break;
8415
8416     case 2 /* NOTE_INFO_THREAD */:
8417       /* Make a ".reg/999" section.  */
8418       /* thread_info.tid */
8419       sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
8420
8421       len = strlen (buf) + 1;
8422       name = (char *) bfd_alloc (abfd, len);
8423       if (name == NULL)
8424         return FALSE;
8425
8426       memcpy (name, buf, len);
8427
8428       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8429       if (sect == NULL)
8430         return FALSE;
8431
8432       /* sizeof (thread_info.thread_context) */
8433       sect->size = 716;
8434       /* offsetof (thread_info.thread_context) */
8435       sect->filepos = note->descpos + 12;
8436       sect->alignment_power = 2;
8437
8438       /* thread_info.is_active_thread */
8439       is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
8440
8441       if (is_active_thread)
8442         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
8443           return FALSE;
8444       break;
8445
8446     case 3 /* NOTE_INFO_MODULE */:
8447       /* Make a ".module/xxxxxxxx" section.  */
8448       /* module_info.base_address */
8449       base_addr = bfd_get_32 (abfd, note->descdata + 4);
8450       sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
8451
8452       len = strlen (buf) + 1;
8453       name = (char *) bfd_alloc (abfd, len);
8454       if (name == NULL)
8455         return FALSE;
8456
8457       memcpy (name, buf, len);
8458
8459       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8460
8461       if (sect == NULL)
8462         return FALSE;
8463
8464       sect->size = note->descsz;
8465       sect->filepos = note->descpos;
8466       sect->alignment_power = 2;
8467       break;
8468
8469     default:
8470       return TRUE;
8471     }
8472
8473   return TRUE;
8474 }
8475
8476 static bfd_boolean
8477 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
8478 {
8479   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8480
8481   switch (note->type)
8482     {
8483     default:
8484       return TRUE;
8485
8486     case NT_PRSTATUS:
8487       if (bed->elf_backend_grok_prstatus)
8488         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
8489           return TRUE;
8490 #if defined (HAVE_PRSTATUS_T)
8491       return elfcore_grok_prstatus (abfd, note);
8492 #else
8493       return TRUE;
8494 #endif
8495
8496 #if defined (HAVE_PSTATUS_T)
8497     case NT_PSTATUS:
8498       return elfcore_grok_pstatus (abfd, note);
8499 #endif
8500
8501 #if defined (HAVE_LWPSTATUS_T)
8502     case NT_LWPSTATUS:
8503       return elfcore_grok_lwpstatus (abfd, note);
8504 #endif
8505
8506     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
8507       return elfcore_grok_prfpreg (abfd, note);
8508
8509     case NT_WIN32PSTATUS:
8510       return elfcore_grok_win32pstatus (abfd, note);
8511
8512     case NT_PRXFPREG:           /* Linux SSE extension */
8513       if (note->namesz == 6
8514           && strcmp (note->namedata, "LINUX") == 0)
8515         return elfcore_grok_prxfpreg (abfd, note);
8516       else
8517         return TRUE;
8518
8519     case NT_X86_XSTATE:         /* Linux XSAVE extension */
8520       if (note->namesz == 6
8521           && strcmp (note->namedata, "LINUX") == 0)
8522         return elfcore_grok_xstatereg (abfd, note);
8523       else
8524         return TRUE;
8525
8526     case NT_PPC_VMX:
8527       if (note->namesz == 6
8528           && strcmp (note->namedata, "LINUX") == 0)
8529         return elfcore_grok_ppc_vmx (abfd, note);
8530       else
8531         return TRUE;
8532
8533     case NT_PPC_VSX:
8534       if (note->namesz == 6
8535           && strcmp (note->namedata, "LINUX") == 0)
8536         return elfcore_grok_ppc_vsx (abfd, note);
8537       else
8538         return TRUE;
8539
8540     case NT_S390_HIGH_GPRS:
8541       if (note->namesz == 6
8542           && strcmp (note->namedata, "LINUX") == 0)
8543         return elfcore_grok_s390_high_gprs (abfd, note);
8544       else
8545         return TRUE;
8546
8547     case NT_S390_TIMER:
8548       if (note->namesz == 6
8549           && strcmp (note->namedata, "LINUX") == 0)
8550         return elfcore_grok_s390_timer (abfd, note);
8551       else
8552         return TRUE;
8553
8554     case NT_S390_TODCMP:
8555       if (note->namesz == 6
8556           && strcmp (note->namedata, "LINUX") == 0)
8557         return elfcore_grok_s390_todcmp (abfd, note);
8558       else
8559         return TRUE;
8560
8561     case NT_S390_TODPREG:
8562       if (note->namesz == 6
8563           && strcmp (note->namedata, "LINUX") == 0)
8564         return elfcore_grok_s390_todpreg (abfd, note);
8565       else
8566         return TRUE;
8567
8568     case NT_S390_CTRS:
8569       if (note->namesz == 6
8570           && strcmp (note->namedata, "LINUX") == 0)
8571         return elfcore_grok_s390_ctrs (abfd, note);
8572       else
8573         return TRUE;
8574
8575     case NT_S390_PREFIX:
8576       if (note->namesz == 6
8577           && strcmp (note->namedata, "LINUX") == 0)
8578         return elfcore_grok_s390_prefix (abfd, note);
8579       else
8580         return TRUE;
8581
8582     case NT_S390_LAST_BREAK:
8583       if (note->namesz == 6
8584           && strcmp (note->namedata, "LINUX") == 0)
8585         return elfcore_grok_s390_last_break (abfd, note);
8586       else
8587         return TRUE;
8588
8589     case NT_S390_SYSTEM_CALL:
8590       if (note->namesz == 6
8591           && strcmp (note->namedata, "LINUX") == 0)
8592         return elfcore_grok_s390_system_call (abfd, note);
8593       else
8594         return TRUE;
8595
8596     case NT_ARM_VFP:
8597       if (note->namesz == 6
8598           && strcmp (note->namedata, "LINUX") == 0)
8599         return elfcore_grok_arm_vfp (abfd, note);
8600       else
8601         return TRUE;
8602
8603     case NT_PRPSINFO:
8604     case NT_PSINFO:
8605       if (bed->elf_backend_grok_psinfo)
8606         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
8607           return TRUE;
8608 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8609       return elfcore_grok_psinfo (abfd, note);
8610 #else
8611       return TRUE;
8612 #endif
8613
8614     case NT_AUXV:
8615       {
8616         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8617                                                              SEC_HAS_CONTENTS);
8618
8619         if (sect == NULL)
8620           return FALSE;
8621         sect->size = note->descsz;
8622         sect->filepos = note->descpos;
8623         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8624
8625         return TRUE;
8626       }
8627
8628     case NT_SIGINFO:
8629       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
8630                                               note);
8631     }
8632 }
8633
8634 static bfd_boolean
8635 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
8636 {
8637   elf_tdata (abfd)->build_id_size = note->descsz;
8638   elf_tdata (abfd)->build_id = (bfd_byte *) bfd_alloc (abfd, note->descsz);
8639   if (elf_tdata (abfd)->build_id == NULL)
8640     return FALSE;
8641
8642   memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
8643
8644   return TRUE;
8645 }
8646
8647 static bfd_boolean
8648 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8649 {
8650   switch (note->type)
8651     {
8652     default:
8653       return TRUE;
8654
8655     case NT_GNU_BUILD_ID:
8656       return elfobj_grok_gnu_build_id (abfd, note);
8657     }
8658 }
8659
8660 static bfd_boolean
8661 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
8662 {
8663   struct sdt_note *cur =
8664     (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
8665                                    + note->descsz);
8666
8667   cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
8668   cur->size = (bfd_size_type) note->descsz;
8669   memcpy (cur->data, note->descdata, note->descsz);
8670
8671   elf_tdata (abfd)->sdt_note_head = cur;
8672
8673   return TRUE;
8674 }
8675
8676 static bfd_boolean
8677 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
8678 {
8679   switch (note->type)
8680     {
8681     case NT_STAPSDT:
8682       return elfobj_grok_stapsdt_note_1 (abfd, note);
8683
8684     default:
8685       return TRUE;
8686     }
8687 }
8688
8689 static bfd_boolean
8690 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
8691 {
8692   char *cp;
8693
8694   cp = strchr (note->namedata, '@');
8695   if (cp != NULL)
8696     {
8697       *lwpidp = atoi(cp + 1);
8698       return TRUE;
8699     }
8700   return FALSE;
8701 }
8702
8703 static bfd_boolean
8704 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8705 {
8706   /* Signal number at offset 0x08. */
8707   elf_tdata (abfd)->core_signal
8708     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8709
8710   /* Process ID at offset 0x50. */
8711   elf_tdata (abfd)->core_pid
8712     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8713
8714   /* Command name at 0x7c (max 32 bytes, including nul). */
8715   elf_tdata (abfd)->core_command
8716     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8717
8718   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8719                                           note);
8720 }
8721
8722 static bfd_boolean
8723 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
8724 {
8725   int lwp;
8726
8727   if (elfcore_netbsd_get_lwpid (note, &lwp))
8728     elf_tdata (abfd)->core_lwpid = lwp;
8729
8730   if (note->type == NT_NETBSDCORE_PROCINFO)
8731     {
8732       /* NetBSD-specific core "procinfo".  Note that we expect to
8733          find this note before any of the others, which is fine,
8734          since the kernel writes this note out first when it
8735          creates a core file.  */
8736
8737       return elfcore_grok_netbsd_procinfo (abfd, note);
8738     }
8739
8740   /* As of Jan 2002 there are no other machine-independent notes
8741      defined for NetBSD core files.  If the note type is less
8742      than the start of the machine-dependent note types, we don't
8743      understand it.  */
8744
8745   if (note->type < NT_NETBSDCORE_FIRSTMACH)
8746     return TRUE;
8747
8748
8749   switch (bfd_get_arch (abfd))
8750     {
8751       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8752          PT_GETFPREGS == mach+2.  */
8753
8754     case bfd_arch_alpha:
8755     case bfd_arch_sparc:
8756       switch (note->type)
8757         {
8758         case NT_NETBSDCORE_FIRSTMACH+0:
8759           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8760
8761         case NT_NETBSDCORE_FIRSTMACH+2:
8762           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8763
8764         default:
8765           return TRUE;
8766         }
8767
8768       /* On all other arch's, PT_GETREGS == mach+1 and
8769          PT_GETFPREGS == mach+3.  */
8770
8771     default:
8772       switch (note->type)
8773         {
8774         case NT_NETBSDCORE_FIRSTMACH+1:
8775           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8776
8777         case NT_NETBSDCORE_FIRSTMACH+3:
8778           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8779
8780         default:
8781           return TRUE;
8782         }
8783     }
8784     /* NOTREACHED */
8785 }
8786
8787 static bfd_boolean
8788 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8789 {
8790   /* Signal number at offset 0x08. */
8791   elf_tdata (abfd)->core_signal
8792     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8793
8794   /* Process ID at offset 0x20. */
8795   elf_tdata (abfd)->core_pid
8796     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
8797
8798   /* Command name at 0x48 (max 32 bytes, including nul). */
8799   elf_tdata (abfd)->core_command
8800     = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
8801
8802   return TRUE;
8803 }
8804
8805 static bfd_boolean
8806 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
8807 {
8808   if (note->type == NT_OPENBSD_PROCINFO)
8809     return elfcore_grok_openbsd_procinfo (abfd, note);
8810
8811   if (note->type == NT_OPENBSD_REGS)
8812     return elfcore_make_note_pseudosection (abfd, ".reg", note);
8813
8814   if (note->type == NT_OPENBSD_FPREGS)
8815     return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8816
8817   if (note->type == NT_OPENBSD_XFPREGS)
8818     return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8819
8820   if (note->type == NT_OPENBSD_AUXV)
8821     {
8822       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8823                                                            SEC_HAS_CONTENTS);
8824
8825       if (sect == NULL)
8826         return FALSE;
8827       sect->size = note->descsz;
8828       sect->filepos = note->descpos;
8829       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8830
8831       return TRUE;
8832     }
8833
8834   if (note->type == NT_OPENBSD_WCOOKIE)
8835     {
8836       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
8837                                                            SEC_HAS_CONTENTS);
8838
8839       if (sect == NULL)
8840         return FALSE;
8841       sect->size = note->descsz;
8842       sect->filepos = note->descpos;
8843       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8844
8845       return TRUE;
8846     }
8847
8848   return TRUE;
8849 }
8850
8851 static bfd_boolean
8852 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8853 {
8854   void *ddata = note->descdata;
8855   char buf[100];
8856   char *name;
8857   asection *sect;
8858   short sig;
8859   unsigned flags;
8860
8861   /* nto_procfs_status 'pid' field is at offset 0.  */
8862   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8863
8864   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
8865   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8866
8867   /* nto_procfs_status 'flags' field is at offset 8.  */
8868   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8869
8870   /* nto_procfs_status 'what' field is at offset 14.  */
8871   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8872     {
8873       elf_tdata (abfd)->core_signal = sig;
8874       elf_tdata (abfd)->core_lwpid = *tid;
8875     }
8876
8877   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
8878      do not come from signals so we make sure we set the current
8879      thread just in case.  */
8880   if (flags & 0x00000080)
8881     elf_tdata (abfd)->core_lwpid = *tid;
8882
8883   /* Make a ".qnx_core_status/%d" section.  */
8884   sprintf (buf, ".qnx_core_status/%ld", *tid);
8885
8886   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8887   if (name == NULL)
8888     return FALSE;
8889   strcpy (name, buf);
8890
8891   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8892   if (sect == NULL)
8893     return FALSE;
8894
8895   sect->size            = note->descsz;
8896   sect->filepos         = note->descpos;
8897   sect->alignment_power = 2;
8898
8899   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8900 }
8901
8902 static bfd_boolean
8903 elfcore_grok_nto_regs (bfd *abfd,
8904                        Elf_Internal_Note *note,
8905                        long tid,
8906                        char *base)
8907 {
8908   char buf[100];
8909   char *name;
8910   asection *sect;
8911
8912   /* Make a "(base)/%d" section.  */
8913   sprintf (buf, "%s/%ld", base, tid);
8914
8915   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8916   if (name == NULL)
8917     return FALSE;
8918   strcpy (name, buf);
8919
8920   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8921   if (sect == NULL)
8922     return FALSE;
8923
8924   sect->size            = note->descsz;
8925   sect->filepos         = note->descpos;
8926   sect->alignment_power = 2;
8927
8928   /* This is the current thread.  */
8929   if (elf_tdata (abfd)->core_lwpid == tid)
8930     return elfcore_maybe_make_sect (abfd, base, sect);
8931
8932   return TRUE;
8933 }
8934
8935 #define BFD_QNT_CORE_INFO       7
8936 #define BFD_QNT_CORE_STATUS     8
8937 #define BFD_QNT_CORE_GREG       9
8938 #define BFD_QNT_CORE_FPREG      10
8939
8940 static bfd_boolean
8941 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8942 {
8943   /* Every GREG section has a STATUS section before it.  Store the
8944      tid from the previous call to pass down to the next gregs
8945      function.  */
8946   static long tid = 1;
8947
8948   switch (note->type)
8949     {
8950     case BFD_QNT_CORE_INFO:
8951       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8952     case BFD_QNT_CORE_STATUS:
8953       return elfcore_grok_nto_status (abfd, note, &tid);
8954     case BFD_QNT_CORE_GREG:
8955       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8956     case BFD_QNT_CORE_FPREG:
8957       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8958     default:
8959       return TRUE;
8960     }
8961 }
8962
8963 static bfd_boolean
8964 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8965 {
8966   char *name;
8967   asection *sect;
8968   size_t len;
8969
8970   /* Use note name as section name.  */
8971   len = note->namesz;
8972   name = (char *) bfd_alloc (abfd, len);
8973   if (name == NULL)
8974     return FALSE;
8975   memcpy (name, note->namedata, len);
8976   name[len - 1] = '\0';
8977
8978   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8979   if (sect == NULL)
8980     return FALSE;
8981
8982   sect->size            = note->descsz;
8983   sect->filepos         = note->descpos;
8984   sect->alignment_power = 1;
8985
8986   return TRUE;
8987 }
8988
8989 /* Function: elfcore_write_note
8990
8991    Inputs:
8992      buffer to hold note, and current size of buffer
8993      name of note
8994      type of note
8995      data for note
8996      size of data for note
8997
8998    Writes note to end of buffer.  ELF64 notes are written exactly as
8999    for ELF32, despite the current (as of 2006) ELF gabi specifying
9000    that they ought to have 8-byte namesz and descsz field, and have
9001    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
9002
9003    Return:
9004    Pointer to realloc'd buffer, *BUFSIZ updated.  */
9005
9006 char *
9007 elfcore_write_note (bfd *abfd,
9008                     char *buf,
9009                     int *bufsiz,
9010                     const char *name,
9011                     int type,
9012                     const void *input,
9013                     int size)
9014 {
9015   Elf_External_Note *xnp;
9016   size_t namesz;
9017   size_t newspace;
9018   char *dest;
9019
9020   namesz = 0;
9021   if (name != NULL)
9022     namesz = strlen (name) + 1;
9023
9024   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
9025
9026   buf = (char *) realloc (buf, *bufsiz + newspace);
9027   if (buf == NULL)
9028     return buf;
9029   dest = buf + *bufsiz;
9030   *bufsiz += newspace;
9031   xnp = (Elf_External_Note *) dest;
9032   H_PUT_32 (abfd, namesz, xnp->namesz);
9033   H_PUT_32 (abfd, size, xnp->descsz);
9034   H_PUT_32 (abfd, type, xnp->type);
9035   dest = xnp->name;
9036   if (name != NULL)
9037     {
9038       memcpy (dest, name, namesz);
9039       dest += namesz;
9040       while (namesz & 3)
9041         {
9042           *dest++ = '\0';
9043           ++namesz;
9044         }
9045     }
9046   memcpy (dest, input, size);
9047   dest += size;
9048   while (size & 3)
9049     {
9050       *dest++ = '\0';
9051       ++size;
9052     }
9053   return buf;
9054 }
9055
9056 char *
9057 elfcore_write_prpsinfo (bfd  *abfd,
9058                         char *buf,
9059                         int  *bufsiz,
9060                         const char *fname,
9061                         const char *psargs)
9062 {
9063   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9064
9065   if (bed->elf_backend_write_core_note != NULL)
9066     {
9067       char *ret;
9068       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
9069                                                  NT_PRPSINFO, fname, psargs);
9070       if (ret != NULL)
9071         return ret;
9072     }
9073
9074 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9075 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9076   if (bed->s->elfclass == ELFCLASS32)
9077     {
9078 #if defined (HAVE_PSINFO32_T)
9079       psinfo32_t data;
9080       int note_type = NT_PSINFO;
9081 #else
9082       prpsinfo32_t data;
9083       int note_type = NT_PRPSINFO;
9084 #endif
9085
9086       memset (&data, 0, sizeof (data));
9087       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
9088       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
9089       return elfcore_write_note (abfd, buf, bufsiz,
9090                                  "CORE", note_type, &data, sizeof (data));
9091     }
9092   else
9093 #endif
9094     {
9095 #if defined (HAVE_PSINFO_T)
9096       psinfo_t data;
9097       int note_type = NT_PSINFO;
9098 #else
9099       prpsinfo_t data;
9100       int note_type = NT_PRPSINFO;
9101 #endif
9102
9103       memset (&data, 0, sizeof (data));
9104       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
9105       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
9106       return elfcore_write_note (abfd, buf, bufsiz,
9107                                  "CORE", note_type, &data, sizeof (data));
9108     }
9109 #endif  /* PSINFO_T or PRPSINFO_T */
9110
9111   free (buf);
9112   return NULL;
9113 }
9114
9115 char *
9116 elfcore_write_prstatus (bfd *abfd,
9117                         char *buf,
9118                         int *bufsiz,
9119                         long pid,
9120                         int cursig,
9121                         const void *gregs)
9122 {
9123   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9124
9125   if (bed->elf_backend_write_core_note != NULL)
9126     {
9127       char *ret;
9128       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
9129                                                  NT_PRSTATUS,
9130                                                  pid, cursig, gregs);
9131       if (ret != NULL)
9132         return ret;
9133     }
9134
9135 #if defined (HAVE_PRSTATUS_T)
9136 #if defined (HAVE_PRSTATUS32_T)
9137   if (bed->s->elfclass == ELFCLASS32)
9138     {
9139       prstatus32_t prstat;
9140
9141       memset (&prstat, 0, sizeof (prstat));
9142       prstat.pr_pid = pid;
9143       prstat.pr_cursig = cursig;
9144       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
9145       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
9146                                  NT_PRSTATUS, &prstat, sizeof (prstat));
9147     }
9148   else
9149 #endif
9150     {
9151       prstatus_t prstat;
9152
9153       memset (&prstat, 0, sizeof (prstat));
9154       prstat.pr_pid = pid;
9155       prstat.pr_cursig = cursig;
9156       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
9157       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
9158                                  NT_PRSTATUS, &prstat, sizeof (prstat));
9159     }
9160 #endif /* HAVE_PRSTATUS_T */
9161
9162   free (buf);
9163   return NULL;
9164 }
9165
9166 #if defined (HAVE_LWPSTATUS_T)
9167 char *
9168 elfcore_write_lwpstatus (bfd *abfd,
9169                          char *buf,
9170                          int *bufsiz,
9171                          long pid,
9172                          int cursig,
9173                          const void *gregs)
9174 {
9175   lwpstatus_t lwpstat;
9176   const char *note_name = "CORE";
9177
9178   memset (&lwpstat, 0, sizeof (lwpstat));
9179   lwpstat.pr_lwpid  = pid >> 16;
9180   lwpstat.pr_cursig = cursig;
9181 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9182   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
9183 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9184 #if !defined(gregs)
9185   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
9186           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
9187 #else
9188   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
9189           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
9190 #endif
9191 #endif
9192   return elfcore_write_note (abfd, buf, bufsiz, note_name,
9193                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
9194 }
9195 #endif /* HAVE_LWPSTATUS_T */
9196
9197 #if defined (HAVE_PSTATUS_T)
9198 char *
9199 elfcore_write_pstatus (bfd *abfd,
9200                        char *buf,
9201                        int *bufsiz,
9202                        long pid,
9203                        int cursig ATTRIBUTE_UNUSED,
9204                        const void *gregs ATTRIBUTE_UNUSED)
9205 {
9206   const char *note_name = "CORE";
9207 #if defined (HAVE_PSTATUS32_T)
9208   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9209
9210   if (bed->s->elfclass == ELFCLASS32)
9211     {
9212       pstatus32_t pstat;
9213
9214       memset (&pstat, 0, sizeof (pstat));
9215       pstat.pr_pid = pid & 0xffff;
9216       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9217                                 NT_PSTATUS, &pstat, sizeof (pstat));
9218       return buf;
9219     }
9220   else
9221 #endif
9222     {
9223       pstatus_t pstat;
9224
9225       memset (&pstat, 0, sizeof (pstat));
9226       pstat.pr_pid = pid & 0xffff;
9227       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9228                                 NT_PSTATUS, &pstat, sizeof (pstat));
9229       return buf;
9230     }
9231 }
9232 #endif /* HAVE_PSTATUS_T */
9233
9234 char *
9235 elfcore_write_prfpreg (bfd *abfd,
9236                        char *buf,
9237                        int *bufsiz,
9238                        const void *fpregs,
9239                        int size)
9240 {
9241   const char *note_name = "CORE";
9242   return elfcore_write_note (abfd, buf, bufsiz,
9243                              note_name, NT_FPREGSET, fpregs, size);
9244 }
9245
9246 char *
9247 elfcore_write_prxfpreg (bfd *abfd,
9248                         char *buf,
9249                         int *bufsiz,
9250                         const void *xfpregs,
9251                         int size)
9252 {
9253   char *note_name = "LINUX";
9254   return elfcore_write_note (abfd, buf, bufsiz,
9255                              note_name, NT_PRXFPREG, xfpregs, size);
9256 }
9257
9258 char *
9259 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
9260                          const void *xfpregs, int size)
9261 {
9262   char *note_name = "LINUX";
9263   return elfcore_write_note (abfd, buf, bufsiz,
9264                              note_name, NT_X86_XSTATE, xfpregs, size);
9265 }
9266
9267 char *
9268 elfcore_write_ppc_vmx (bfd *abfd,
9269                        char *buf,
9270                        int *bufsiz,
9271                        const void *ppc_vmx,
9272                        int size)
9273 {
9274   char *note_name = "LINUX";
9275   return elfcore_write_note (abfd, buf, bufsiz,
9276                              note_name, NT_PPC_VMX, ppc_vmx, size);
9277 }
9278
9279 char *
9280 elfcore_write_ppc_vsx (bfd *abfd,
9281                        char *buf,
9282                        int *bufsiz,
9283                        const void *ppc_vsx,
9284                        int size)
9285 {
9286   char *note_name = "LINUX";
9287   return elfcore_write_note (abfd, buf, bufsiz,
9288                              note_name, NT_PPC_VSX, ppc_vsx, size);
9289 }
9290
9291 static char *
9292 elfcore_write_s390_high_gprs (bfd *abfd,
9293                               char *buf,
9294                               int *bufsiz,
9295                               const void *s390_high_gprs,
9296                               int size)
9297 {
9298   char *note_name = "LINUX";
9299   return elfcore_write_note (abfd, buf, bufsiz,
9300                              note_name, NT_S390_HIGH_GPRS,
9301                              s390_high_gprs, size);
9302 }
9303
9304 char *
9305 elfcore_write_s390_timer (bfd *abfd,
9306                           char *buf,
9307                           int *bufsiz,
9308                           const void *s390_timer,
9309                           int size)
9310 {
9311   char *note_name = "LINUX";
9312   return elfcore_write_note (abfd, buf, bufsiz,
9313                              note_name, NT_S390_TIMER, s390_timer, size);
9314 }
9315
9316 char *
9317 elfcore_write_s390_todcmp (bfd *abfd,
9318                            char *buf,
9319                            int *bufsiz,
9320                            const void *s390_todcmp,
9321                            int size)
9322 {
9323   char *note_name = "LINUX";
9324   return elfcore_write_note (abfd, buf, bufsiz,
9325                              note_name, NT_S390_TODCMP, s390_todcmp, size);
9326 }
9327
9328 char *
9329 elfcore_write_s390_todpreg (bfd *abfd,
9330                             char *buf,
9331                             int *bufsiz,
9332                             const void *s390_todpreg,
9333                             int size)
9334 {
9335   char *note_name = "LINUX";
9336   return elfcore_write_note (abfd, buf, bufsiz,
9337                              note_name, NT_S390_TODPREG, s390_todpreg, size);
9338 }
9339
9340 char *
9341 elfcore_write_s390_ctrs (bfd *abfd,
9342                          char *buf,
9343                          int *bufsiz,
9344                          const void *s390_ctrs,
9345                          int size)
9346 {
9347   char *note_name = "LINUX";
9348   return elfcore_write_note (abfd, buf, bufsiz,
9349                              note_name, NT_S390_CTRS, s390_ctrs, size);
9350 }
9351
9352 char *
9353 elfcore_write_s390_prefix (bfd *abfd,
9354                            char *buf,
9355                            int *bufsiz,
9356                            const void *s390_prefix,
9357                            int size)
9358 {
9359   char *note_name = "LINUX";
9360   return elfcore_write_note (abfd, buf, bufsiz,
9361                              note_name, NT_S390_PREFIX, s390_prefix, size);
9362 }
9363
9364 char *
9365 elfcore_write_s390_last_break (bfd *abfd,
9366                                char *buf,
9367                                int *bufsiz,
9368                                const void *s390_last_break,
9369                                int size)
9370 {
9371   char *note_name = "LINUX";
9372   return elfcore_write_note (abfd, buf, bufsiz,
9373                              note_name, NT_S390_LAST_BREAK,
9374                              s390_last_break, size);
9375 }
9376
9377 char *
9378 elfcore_write_s390_system_call (bfd *abfd,
9379                                 char *buf,
9380                                 int *bufsiz,
9381                                 const void *s390_system_call,
9382                                 int size)
9383 {
9384   char *note_name = "LINUX";
9385   return elfcore_write_note (abfd, buf, bufsiz,
9386                              note_name, NT_S390_SYSTEM_CALL,
9387                              s390_system_call, size);
9388 }
9389
9390 char *
9391 elfcore_write_arm_vfp (bfd *abfd,
9392                        char *buf,
9393                        int *bufsiz,
9394                        const void *arm_vfp,
9395                        int size)
9396 {
9397   char *note_name = "LINUX";
9398   return elfcore_write_note (abfd, buf, bufsiz,
9399                              note_name, NT_ARM_VFP, arm_vfp, size);
9400 }
9401
9402 char *
9403 elfcore_write_register_note (bfd *abfd,
9404                              char *buf,
9405                              int *bufsiz,
9406                              const char *section,
9407                              const void *data,
9408                              int size)
9409 {
9410   if (strcmp (section, ".reg2") == 0)
9411     return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
9412   if (strcmp (section, ".reg-xfp") == 0)
9413     return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
9414   if (strcmp (section, ".reg-xstate") == 0)
9415     return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
9416   if (strcmp (section, ".reg-ppc-vmx") == 0)
9417     return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
9418   if (strcmp (section, ".reg-ppc-vsx") == 0)
9419     return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
9420   if (strcmp (section, ".reg-s390-high-gprs") == 0)
9421     return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
9422   if (strcmp (section, ".reg-s390-timer") == 0)
9423     return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
9424   if (strcmp (section, ".reg-s390-todcmp") == 0)
9425     return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
9426   if (strcmp (section, ".reg-s390-todpreg") == 0)
9427     return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
9428   if (strcmp (section, ".reg-s390-ctrs") == 0)
9429     return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
9430   if (strcmp (section, ".reg-s390-prefix") == 0)
9431     return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
9432   if (strcmp (section, ".reg-s390-last-break") == 0)
9433     return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
9434   if (strcmp (section, ".reg-s390-system-call") == 0)
9435     return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
9436   if (strcmp (section, ".reg-arm-vfp") == 0)
9437     return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
9438   return NULL;
9439 }
9440
9441 static bfd_boolean
9442 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
9443 {
9444   char *p;
9445
9446   p = buf;
9447   while (p < buf + size)
9448     {
9449       /* FIXME: bad alignment assumption.  */
9450       Elf_External_Note *xnp = (Elf_External_Note *) p;
9451       Elf_Internal_Note in;
9452
9453       if (offsetof (Elf_External_Note, name) > buf - p + size)
9454         return FALSE;
9455
9456       in.type = H_GET_32 (abfd, xnp->type);
9457
9458       in.namesz = H_GET_32 (abfd, xnp->namesz);
9459       in.namedata = xnp->name;
9460       if (in.namesz > buf - in.namedata + size)
9461         return FALSE;
9462
9463       in.descsz = H_GET_32 (abfd, xnp->descsz);
9464       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
9465       in.descpos = offset + (in.descdata - buf);
9466       if (in.descsz != 0
9467           && (in.descdata >= buf + size
9468               || in.descsz > buf - in.descdata + size))
9469         return FALSE;
9470
9471       switch (bfd_get_format (abfd))
9472         {
9473         default:
9474           return TRUE;
9475
9476         case bfd_core:
9477           if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
9478             {
9479               if (! elfcore_grok_netbsd_note (abfd, &in))
9480                 return FALSE;
9481             }
9482           else if (CONST_STRNEQ (in.namedata, "OpenBSD"))
9483             {
9484               if (! elfcore_grok_openbsd_note (abfd, &in))
9485                 return FALSE;
9486             }
9487           else if (CONST_STRNEQ (in.namedata, "QNX"))
9488             {
9489               if (! elfcore_grok_nto_note (abfd, &in))
9490                 return FALSE;
9491             }
9492           else if (CONST_STRNEQ (in.namedata, "SPU/"))
9493             {
9494               if (! elfcore_grok_spu_note (abfd, &in))
9495                 return FALSE;
9496             }
9497           else
9498             {
9499               if (! elfcore_grok_note (abfd, &in))
9500                 return FALSE;
9501             }
9502           break;
9503
9504         case bfd_object:
9505           if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
9506             {
9507               if (! elfobj_grok_gnu_note (abfd, &in))
9508                 return FALSE;
9509             }
9510           else if (in.namesz == sizeof "stapsdt"
9511                    && strcmp (in.namedata, "stapsdt") == 0)
9512             {
9513               if (! elfobj_grok_stapsdt_note (abfd, &in))
9514                 return FALSE;
9515             }
9516           break;
9517         }
9518
9519       p = in.descdata + BFD_ALIGN (in.descsz, 4);
9520     }
9521
9522   return TRUE;
9523 }
9524
9525 static bfd_boolean
9526 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
9527 {
9528   char *buf;
9529
9530   if (size <= 0)
9531     return TRUE;
9532
9533   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
9534     return FALSE;
9535
9536   buf = (char *) bfd_malloc (size);
9537   if (buf == NULL)
9538     return FALSE;
9539
9540   if (bfd_bread (buf, size, abfd) != size
9541       || !elf_parse_notes (abfd, buf, size, offset))
9542     {
9543       free (buf);
9544       return FALSE;
9545     }
9546
9547   free (buf);
9548   return TRUE;
9549 }
9550 \f
9551 /* Providing external access to the ELF program header table.  */
9552
9553 /* Return an upper bound on the number of bytes required to store a
9554    copy of ABFD's program header table entries.  Return -1 if an error
9555    occurs; bfd_get_error will return an appropriate code.  */
9556
9557 long
9558 bfd_get_elf_phdr_upper_bound (bfd *abfd)
9559 {
9560   if (abfd->xvec->flavour != bfd_target_elf_flavour)
9561     {
9562       bfd_set_error (bfd_error_wrong_format);
9563       return -1;
9564     }
9565
9566   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
9567 }
9568
9569 /* Copy ABFD's program header table entries to *PHDRS.  The entries
9570    will be stored as an array of Elf_Internal_Phdr structures, as
9571    defined in include/elf/internal.h.  To find out how large the
9572    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9573
9574    Return the number of program header table entries read, or -1 if an
9575    error occurs; bfd_get_error will return an appropriate code.  */
9576
9577 int
9578 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
9579 {
9580   int num_phdrs;
9581
9582   if (abfd->xvec->flavour != bfd_target_elf_flavour)
9583     {
9584       bfd_set_error (bfd_error_wrong_format);
9585       return -1;
9586     }
9587
9588   num_phdrs = elf_elfheader (abfd)->e_phnum;
9589   memcpy (phdrs, elf_tdata (abfd)->phdr,
9590           num_phdrs * sizeof (Elf_Internal_Phdr));
9591
9592   return num_phdrs;
9593 }
9594
9595 enum elf_reloc_type_class
9596 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
9597 {
9598   return reloc_class_normal;
9599 }
9600
9601 /* For RELA architectures, return the relocation value for a
9602    relocation against a local symbol.  */
9603
9604 bfd_vma
9605 _bfd_elf_rela_local_sym (bfd *abfd,
9606                          Elf_Internal_Sym *sym,
9607                          asection **psec,
9608                          Elf_Internal_Rela *rel)
9609 {
9610   asection *sec = *psec;
9611   bfd_vma relocation;
9612
9613   relocation = (sec->output_section->vma
9614                 + sec->output_offset
9615                 + sym->st_value);
9616   if ((sec->flags & SEC_MERGE)
9617       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
9618       && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
9619     {
9620       rel->r_addend =
9621         _bfd_merged_section_offset (abfd, psec,
9622                                     elf_section_data (sec)->sec_info,
9623                                     sym->st_value + rel->r_addend);
9624       if (sec != *psec)
9625         {
9626           /* If we have changed the section, and our original section is
9627              marked with SEC_EXCLUDE, it means that the original
9628              SEC_MERGE section has been completely subsumed in some
9629              other SEC_MERGE section.  In this case, we need to leave
9630              some info around for --emit-relocs.  */
9631           if ((sec->flags & SEC_EXCLUDE) != 0)
9632             sec->kept_section = *psec;
9633           sec = *psec;
9634         }
9635       rel->r_addend -= relocation;
9636       rel->r_addend += sec->output_section->vma + sec->output_offset;
9637     }
9638   return relocation;
9639 }
9640
9641 bfd_vma
9642 _bfd_elf_rel_local_sym (bfd *abfd,
9643                         Elf_Internal_Sym *sym,
9644                         asection **psec,
9645                         bfd_vma addend)
9646 {
9647   asection *sec = *psec;
9648
9649   if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
9650     return sym->st_value + addend;
9651
9652   return _bfd_merged_section_offset (abfd, psec,
9653                                      elf_section_data (sec)->sec_info,
9654                                      sym->st_value + addend);
9655 }
9656
9657 bfd_vma
9658 _bfd_elf_section_offset (bfd *abfd,
9659                          struct bfd_link_info *info,
9660                          asection *sec,
9661                          bfd_vma offset)
9662 {
9663   switch (sec->sec_info_type)
9664     {
9665     case SEC_INFO_TYPE_STABS:
9666       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
9667                                        offset);
9668     case SEC_INFO_TYPE_EH_FRAME:
9669       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
9670     default:
9671       if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
9672         {
9673           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9674           bfd_size_type address_size = bed->s->arch_size / 8;
9675           offset = sec->size - offset - address_size;
9676         }
9677       return offset;
9678     }
9679 }
9680 \f
9681 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
9682    reconstruct an ELF file by reading the segments out of remote memory
9683    based on the ELF file header at EHDR_VMA and the ELF program headers it
9684    points to.  If not null, *LOADBASEP is filled in with the difference
9685    between the VMAs from which the segments were read, and the VMAs the
9686    file headers (and hence BFD's idea of each section's VMA) put them at.
9687
9688    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
9689    remote memory at target address VMA into the local buffer at MYADDR; it
9690    should return zero on success or an `errno' code on failure.  TEMPL must
9691    be a BFD for an ELF target with the word size and byte order found in
9692    the remote memory.  */
9693
9694 bfd *
9695 bfd_elf_bfd_from_remote_memory
9696   (bfd *templ,
9697    bfd_vma ehdr_vma,
9698    bfd_vma *loadbasep,
9699    int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
9700 {
9701   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
9702     (templ, ehdr_vma, loadbasep, target_read_memory);
9703 }
9704 \f
9705 long
9706 _bfd_elf_get_synthetic_symtab (bfd *abfd,
9707                                long symcount ATTRIBUTE_UNUSED,
9708                                asymbol **syms ATTRIBUTE_UNUSED,
9709                                long dynsymcount,
9710                                asymbol **dynsyms,
9711                                asymbol **ret)
9712 {
9713   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9714   asection *relplt;
9715   asymbol *s;
9716   const char *relplt_name;
9717   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
9718   arelent *p;
9719   long count, i, n;
9720   size_t size;
9721   Elf_Internal_Shdr *hdr;
9722   char *names;
9723   asection *plt;
9724
9725   *ret = NULL;
9726
9727   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
9728     return 0;
9729
9730   if (dynsymcount <= 0)
9731     return 0;
9732
9733   if (!bed->plt_sym_val)
9734     return 0;
9735
9736   relplt_name = bed->relplt_name;
9737   if (relplt_name == NULL)
9738     relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
9739   relplt = bfd_get_section_by_name (abfd, relplt_name);
9740   if (relplt == NULL)
9741     return 0;
9742
9743   hdr = &elf_section_data (relplt)->this_hdr;
9744   if (hdr->sh_link != elf_dynsymtab (abfd)
9745       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
9746     return 0;
9747
9748   plt = bfd_get_section_by_name (abfd, ".plt");
9749   if (plt == NULL)
9750     return 0;
9751
9752   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
9753   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
9754     return -1;
9755
9756   count = relplt->size / hdr->sh_entsize;
9757   size = count * sizeof (asymbol);
9758   p = relplt->relocation;
9759   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9760     {
9761       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
9762       if (p->addend != 0)
9763         {
9764 #ifdef BFD64
9765           size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
9766 #else
9767           size += sizeof ("+0x") - 1 + 8;
9768 #endif
9769         }
9770     }
9771
9772   s = *ret = (asymbol *) bfd_malloc (size);
9773   if (s == NULL)
9774     return -1;
9775
9776   names = (char *) (s + count);
9777   p = relplt->relocation;
9778   n = 0;
9779   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9780     {
9781       size_t len;
9782       bfd_vma addr;
9783
9784       addr = bed->plt_sym_val (i, plt, p);
9785       if (addr == (bfd_vma) -1)
9786         continue;
9787
9788       *s = **p->sym_ptr_ptr;
9789       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
9790          we are defining a symbol, ensure one of them is set.  */
9791       if ((s->flags & BSF_LOCAL) == 0)
9792         s->flags |= BSF_GLOBAL;
9793       s->flags |= BSF_SYNTHETIC;
9794       s->section = plt;
9795       s->value = addr - plt->vma;
9796       s->name = names;
9797       s->udata.p = NULL;
9798       len = strlen ((*p->sym_ptr_ptr)->name);
9799       memcpy (names, (*p->sym_ptr_ptr)->name, len);
9800       names += len;
9801       if (p->addend != 0)
9802         {
9803           char buf[30], *a;
9804
9805           memcpy (names, "+0x", sizeof ("+0x") - 1);
9806           names += sizeof ("+0x") - 1;
9807           bfd_sprintf_vma (abfd, buf, p->addend);
9808           for (a = buf; *a == '0'; ++a)
9809             ;
9810           len = strlen (a);
9811           memcpy (names, a, len);
9812           names += len;
9813         }
9814       memcpy (names, "@plt", sizeof ("@plt"));
9815       names += sizeof ("@plt");
9816       ++s, ++n;
9817     }
9818
9819   return n;
9820 }
9821
9822 /* It is only used by x86-64 so far.  */
9823 asection _bfd_elf_large_com_section
9824   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
9825                       SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
9826
9827 void
9828 _bfd_elf_set_osabi (bfd * abfd,
9829                     struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
9830 {
9831   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
9832
9833   i_ehdrp = elf_elfheader (abfd);
9834
9835   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
9836
9837   /* To make things simpler for the loader on Linux systems we set the
9838      osabi field to ELFOSABI_GNU if the binary contains symbols of
9839      the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding.  */
9840   if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
9841       && elf_tdata (abfd)->has_gnu_symbols)
9842     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
9843 }
9844
9845
9846 /* Return TRUE for ELF symbol types that represent functions.
9847    This is the default version of this function, which is sufficient for
9848    most targets.  It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC.  */
9849
9850 bfd_boolean
9851 _bfd_elf_is_function_type (unsigned int type)
9852 {
9853   return (type == STT_FUNC
9854           || type == STT_GNU_IFUNC);
9855 }
9856
9857 /* If the ELF symbol SYM might be a function in SEC, return the
9858    function size and set *CODE_OFF to the function's entry point,
9859    otherwise return zero.  */
9860
9861 bfd_size_type
9862 _bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
9863                              bfd_vma *code_off)
9864 {
9865   bfd_size_type size;
9866
9867   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
9868                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
9869       || sym->section != sec)
9870     return 0;
9871
9872   *code_off = sym->value;
9873   size = 0;
9874   if (!(sym->flags & BSF_SYNTHETIC))
9875     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
9876   if (size == 0)
9877     size = 1;
9878   return size;
9879 }