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           phdr_size += bed->s->sizeof_ehdr;
3878           if ((abfd->flags & D_PAGED) == 0
3879               || (sections[0]->lma & addr_mask) < phdr_size
3880               || ((sections[0]->lma & addr_mask) % maxpagesize
3881                   < phdr_size % maxpagesize)
3882               || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to)
3883             phdr_in_segment = FALSE;
3884         }
3885
3886       for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3887         {
3888           asection *hdr;
3889           bfd_boolean new_segment;
3890
3891           hdr = *hdrpp;
3892
3893           /* See if this section and the last one will fit in the same
3894              segment.  */
3895
3896           if (last_hdr == NULL)
3897             {
3898               /* If we don't have a segment yet, then we don't need a new
3899                  one (we build the last one after this loop).  */
3900               new_segment = FALSE;
3901             }
3902           else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3903             {
3904               /* If this section has a different relation between the
3905                  virtual address and the load address, then we need a new
3906                  segment.  */
3907               new_segment = TRUE;
3908             }
3909           else if (hdr->lma < last_hdr->lma + last_size
3910                    || last_hdr->lma + last_size < last_hdr->lma)
3911             {
3912               /* If this section has a load address that makes it overlap
3913                  the previous section, then we need a new segment.  */
3914               new_segment = TRUE;
3915             }
3916           /* In the next test we have to be careful when last_hdr->lma is close
3917              to the end of the address space.  If the aligned address wraps
3918              around to the start of the address space, then there are no more
3919              pages left in memory and it is OK to assume that the current
3920              section can be included in the current segment.  */
3921           else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3922                     > last_hdr->lma)
3923                    && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3924                        <= hdr->lma))
3925             {
3926               /* If putting this section in this segment would force us to
3927                  skip a page in the segment, then we need a new segment.  */
3928               new_segment = TRUE;
3929             }
3930           else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3931                    && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3932             {
3933               /* We don't want to put a loadable section after a
3934                  nonloadable section in the same segment.
3935                  Consider .tbss sections as loadable for this purpose.  */
3936               new_segment = TRUE;
3937             }
3938           else if ((abfd->flags & D_PAGED) == 0)
3939             {
3940               /* If the file is not demand paged, which means that we
3941                  don't require the sections to be correctly aligned in the
3942                  file, then there is no other reason for a new segment.  */
3943               new_segment = FALSE;
3944             }
3945           else if (! writable
3946                    && (hdr->flags & SEC_READONLY) == 0
3947                    && (((last_hdr->lma + last_size - 1) & -maxpagesize)
3948                        != (hdr->lma & -maxpagesize)))
3949             {
3950               /* We don't want to put a writable section in a read only
3951                  segment, unless they are on the same page in memory
3952                  anyhow.  We already know that the last section does not
3953                  bring us past the current section on the page, so the
3954                  only case in which the new section is not on the same
3955                  page as the previous section is when the previous section
3956                  ends precisely on a page boundary.  */
3957               new_segment = TRUE;
3958             }
3959           else
3960             {
3961               /* Otherwise, we can use the same segment.  */
3962               new_segment = FALSE;
3963             }
3964
3965           /* Allow interested parties a chance to override our decision.  */
3966           if (last_hdr != NULL
3967               && info != NULL
3968               && info->callbacks->override_segment_assignment != NULL)
3969             new_segment
3970               = info->callbacks->override_segment_assignment (info, abfd, hdr,
3971                                                               last_hdr,
3972                                                               new_segment);
3973
3974           if (! new_segment)
3975             {
3976               if ((hdr->flags & SEC_READONLY) == 0)
3977                 writable = TRUE;
3978               last_hdr = hdr;
3979               /* .tbss sections effectively have zero size.  */
3980               if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3981                   != SEC_THREAD_LOCAL)
3982                 last_size = hdr->size;
3983               else
3984                 last_size = 0;
3985               continue;
3986             }
3987
3988           /* We need a new program segment.  We must create a new program
3989              header holding all the sections from phdr_index until hdr.  */
3990
3991           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3992           if (m == NULL)
3993             goto error_return;
3994
3995           *pm = m;
3996           pm = &m->next;
3997
3998           if ((hdr->flags & SEC_READONLY) == 0)
3999             writable = TRUE;
4000           else
4001             writable = FALSE;
4002
4003           last_hdr = hdr;
4004           /* .tbss sections effectively have zero size.  */
4005           if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
4006             last_size = hdr->size;
4007           else
4008             last_size = 0;
4009           phdr_index = i;
4010           phdr_in_segment = FALSE;
4011         }
4012
4013       /* Create a final PT_LOAD program segment, but not if it's just
4014          for .tbss.  */
4015       if (last_hdr != NULL
4016           && (i - phdr_index != 1
4017               || ((last_hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
4018                   != SEC_THREAD_LOCAL)))
4019         {
4020           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4021           if (m == NULL)
4022             goto error_return;
4023
4024           *pm = m;
4025           pm = &m->next;
4026         }
4027
4028       /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
4029       if (dynsec != NULL)
4030         {
4031           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4032           if (m == NULL)
4033             goto error_return;
4034           *pm = m;
4035           pm = &m->next;
4036         }
4037
4038       /* For each batch of consecutive loadable .note sections,
4039          add a PT_NOTE segment.  We don't use bfd_get_section_by_name,
4040          because if we link together nonloadable .note sections and
4041          loadable .note sections, we will generate two .note sections
4042          in the output file.  FIXME: Using names for section types is
4043          bogus anyhow.  */
4044       for (s = abfd->sections; s != NULL; s = s->next)
4045         {
4046           if ((s->flags & SEC_LOAD) != 0
4047               && CONST_STRNEQ (s->name, ".note"))
4048             {
4049               asection *s2;
4050
4051               count = 1;
4052               amt = sizeof (struct elf_segment_map);
4053               if (s->alignment_power == 2)
4054                 for (s2 = s; s2->next != NULL; s2 = s2->next)
4055                   {
4056                     if (s2->next->alignment_power == 2
4057                         && (s2->next->flags & SEC_LOAD) != 0
4058                         && CONST_STRNEQ (s2->next->name, ".note")
4059                         && align_power (s2->lma + s2->size, 2)
4060                            == s2->next->lma)
4061                       count++;
4062                     else
4063                       break;
4064                   }
4065               amt += (count - 1) * sizeof (asection *);
4066               m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4067               if (m == NULL)
4068                 goto error_return;
4069               m->next = NULL;
4070               m->p_type = PT_NOTE;
4071               m->count = count;
4072               while (count > 1)
4073                 {
4074                   m->sections[m->count - count--] = s;
4075                   BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4076                   s = s->next;
4077                 }
4078               m->sections[m->count - 1] = s;
4079               BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4080               *pm = m;
4081               pm = &m->next;
4082             }
4083           if (s->flags & SEC_THREAD_LOCAL)
4084             {
4085               if (! tls_count)
4086                 first_tls = s;
4087               tls_count++;
4088             }
4089         }
4090
4091       /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
4092       if (tls_count > 0)
4093         {
4094           amt = sizeof (struct elf_segment_map);
4095           amt += (tls_count - 1) * sizeof (asection *);
4096           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4097           if (m == NULL)
4098             goto error_return;
4099           m->next = NULL;
4100           m->p_type = PT_TLS;
4101           m->count = tls_count;
4102           /* Mandated PF_R.  */
4103           m->p_flags = PF_R;
4104           m->p_flags_valid = 1;
4105           for (i = 0; i < (unsigned int) tls_count; ++i)
4106             {
4107               BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
4108               m->sections[i] = first_tls;
4109               first_tls = first_tls->next;
4110             }
4111
4112           *pm = m;
4113           pm = &m->next;
4114         }
4115
4116       /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4117          segment.  */
4118       eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
4119       if (eh_frame_hdr != NULL
4120           && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
4121         {
4122           amt = sizeof (struct elf_segment_map);
4123           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4124           if (m == NULL)
4125             goto error_return;
4126           m->next = NULL;
4127           m->p_type = PT_GNU_EH_FRAME;
4128           m->count = 1;
4129           m->sections[0] = eh_frame_hdr->output_section;
4130
4131           *pm = m;
4132           pm = &m->next;
4133         }
4134
4135       if (elf_tdata (abfd)->stack_flags)
4136         {
4137           amt = sizeof (struct elf_segment_map);
4138           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4139           if (m == NULL)
4140             goto error_return;
4141           m->next = NULL;
4142           m->p_type = PT_GNU_STACK;
4143           m->p_flags = elf_tdata (abfd)->stack_flags;
4144           m->p_align = bed->stack_align;
4145           m->p_flags_valid = 1;
4146           m->p_align_valid = m->p_align != 0;
4147           if (info->stacksize > 0)
4148             {
4149               m->p_size = info->stacksize;
4150               m->p_size_valid = 1;
4151             }
4152
4153           *pm = m;
4154           pm = &m->next;
4155         }
4156
4157       if (info != NULL && info->relro)
4158         {
4159           for (m = mfirst; m != NULL; m = m->next)
4160             {
4161               if (m->p_type == PT_LOAD
4162                   && m->count != 0
4163                   && m->sections[0]->vma >= info->relro_start
4164                   && m->sections[0]->vma < info->relro_end)
4165                 {
4166                   i = m->count;
4167                   while (--i != (unsigned) -1)
4168                     if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS))
4169                         == (SEC_LOAD | SEC_HAS_CONTENTS))
4170                       break;
4171
4172                   if (i == (unsigned) -1)
4173                     continue;
4174
4175                   if (m->sections[i]->vma + m->sections[i]->size
4176                       >= info->relro_end)
4177                     break;
4178                 }
4179             }
4180
4181           /* Make a PT_GNU_RELRO segment only when it isn't empty.  */
4182           if (m != NULL)
4183             {
4184               amt = sizeof (struct elf_segment_map);
4185               m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4186               if (m == NULL)
4187                 goto error_return;
4188               m->next = NULL;
4189               m->p_type = PT_GNU_RELRO;
4190               m->p_flags = PF_R;
4191               m->p_flags_valid = 1;
4192
4193               *pm = m;
4194               pm = &m->next;
4195             }
4196         }
4197
4198       free (sections);
4199       elf_tdata (abfd)->segment_map = mfirst;
4200     }
4201
4202   if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
4203     return FALSE;
4204
4205   for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4206     ++count;
4207   elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr;
4208
4209   return TRUE;
4210
4211  error_return:
4212   if (sections != NULL)
4213     free (sections);
4214   return FALSE;
4215 }
4216
4217 /* Sort sections by address.  */
4218
4219 static int
4220 elf_sort_sections (const void *arg1, const void *arg2)
4221 {
4222   const asection *sec1 = *(const asection **) arg1;
4223   const asection *sec2 = *(const asection **) arg2;
4224   bfd_size_type size1, size2;
4225
4226   /* Sort by LMA first, since this is the address used to
4227      place the section into a segment.  */
4228   if (sec1->lma < sec2->lma)
4229     return -1;
4230   else if (sec1->lma > sec2->lma)
4231     return 1;
4232
4233   /* Then sort by VMA.  Normally the LMA and the VMA will be
4234      the same, and this will do nothing.  */
4235   if (sec1->vma < sec2->vma)
4236     return -1;
4237   else if (sec1->vma > sec2->vma)
4238     return 1;
4239
4240   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
4241
4242 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4243
4244   if (TOEND (sec1))
4245     {
4246       if (TOEND (sec2))
4247         {
4248           /* If the indicies are the same, do not return 0
4249              here, but continue to try the next comparison.  */
4250           if (sec1->target_index - sec2->target_index != 0)
4251             return sec1->target_index - sec2->target_index;
4252         }
4253       else
4254         return 1;
4255     }
4256   else if (TOEND (sec2))
4257     return -1;
4258
4259 #undef TOEND
4260
4261   /* Sort by size, to put zero sized sections
4262      before others at the same address.  */
4263
4264   size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4265   size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4266
4267   if (size1 < size2)
4268     return -1;
4269   if (size1 > size2)
4270     return 1;
4271
4272   return sec1->target_index - sec2->target_index;
4273 }
4274
4275 /* Ian Lance Taylor writes:
4276
4277    We shouldn't be using % with a negative signed number.  That's just
4278    not good.  We have to make sure either that the number is not
4279    negative, or that the number has an unsigned type.  When the types
4280    are all the same size they wind up as unsigned.  When file_ptr is a
4281    larger signed type, the arithmetic winds up as signed long long,
4282    which is wrong.
4283
4284    What we're trying to say here is something like ``increase OFF by
4285    the least amount that will cause it to be equal to the VMA modulo
4286    the page size.''  */
4287 /* In other words, something like:
4288
4289    vma_offset = m->sections[0]->vma % bed->maxpagesize;
4290    off_offset = off % bed->maxpagesize;
4291    if (vma_offset < off_offset)
4292      adjustment = vma_offset + bed->maxpagesize - off_offset;
4293    else
4294      adjustment = vma_offset - off_offset;
4295
4296    which can can be collapsed into the expression below.  */
4297
4298 static file_ptr
4299 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4300 {
4301   return ((vma - off) % maxpagesize);
4302 }
4303
4304 static void
4305 print_segment_map (const struct elf_segment_map *m)
4306 {
4307   unsigned int j;
4308   const char *pt = get_segment_type (m->p_type);
4309   char buf[32];
4310
4311   if (pt == NULL)
4312     {
4313       if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4314         sprintf (buf, "LOPROC+%7.7x",
4315                  (unsigned int) (m->p_type - PT_LOPROC));
4316       else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4317         sprintf (buf, "LOOS+%7.7x",
4318                  (unsigned int) (m->p_type - PT_LOOS));
4319       else
4320         snprintf (buf, sizeof (buf), "%8.8x",
4321                   (unsigned int) m->p_type);
4322       pt = buf;
4323     }
4324   fflush (stdout);
4325   fprintf (stderr, "%s:", pt);
4326   for (j = 0; j < m->count; j++)
4327     fprintf (stderr, " %s", m->sections [j]->name);
4328   putc ('\n',stderr);
4329   fflush (stderr);
4330 }
4331
4332 static bfd_boolean
4333 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
4334 {
4335   void *buf;
4336   bfd_boolean ret;
4337
4338   if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4339     return FALSE;
4340   buf = bfd_zmalloc (len);
4341   if (buf == NULL)
4342     return FALSE;
4343   ret = bfd_bwrite (buf, len, abfd) == len;
4344   free (buf);
4345   return ret;
4346 }
4347
4348 /* Assign file positions to the sections based on the mapping from
4349    sections to segments.  This function also sets up some fields in
4350    the file header.  */
4351
4352 static bfd_boolean
4353 assign_file_positions_for_load_sections (bfd *abfd,
4354                                          struct bfd_link_info *link_info)
4355 {
4356   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4357   struct elf_segment_map *m;
4358   Elf_Internal_Phdr *phdrs;
4359   Elf_Internal_Phdr *p;
4360   file_ptr off;
4361   bfd_size_type maxpagesize;
4362   unsigned int alloc;
4363   unsigned int i, j;
4364   bfd_vma header_pad = 0;
4365
4366   if (link_info == NULL
4367       && !_bfd_elf_map_sections_to_segments (abfd, link_info))
4368     return FALSE;
4369
4370   alloc = 0;
4371   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4372     {
4373       ++alloc;
4374       if (m->header_size)
4375         header_pad = m->header_size;
4376     }
4377
4378   if (alloc)
4379     {
4380       elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4381       elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4382     }
4383   else
4384     {
4385       /* PR binutils/12467.  */
4386       elf_elfheader (abfd)->e_phoff = 0;
4387       elf_elfheader (abfd)->e_phentsize = 0;
4388     }
4389
4390   elf_elfheader (abfd)->e_phnum = alloc;
4391
4392   if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1)
4393     elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr;
4394   else
4395     BFD_ASSERT (elf_tdata (abfd)->program_header_size
4396                 >= alloc * bed->s->sizeof_phdr);
4397
4398   if (alloc == 0)
4399     {
4400       elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4401       return TRUE;
4402     }
4403
4404   /* We're writing the size in elf_tdata (abfd)->program_header_size,
4405      see assign_file_positions_except_relocs, so make sure we have
4406      that amount allocated, with trailing space cleared.
4407      The variable alloc contains the computed need, while elf_tdata
4408      (abfd)->program_header_size contains the size used for the
4409      layout.
4410      See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4411      where the layout is forced to according to a larger size in the
4412      last iterations for the testcase ld-elf/header.  */
4413   BFD_ASSERT (elf_tdata (abfd)->program_header_size % bed->s->sizeof_phdr
4414               == 0);
4415   phdrs = (Elf_Internal_Phdr *)
4416      bfd_zalloc2 (abfd,
4417                   (elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr),
4418                   sizeof (Elf_Internal_Phdr));
4419   elf_tdata (abfd)->phdr = phdrs;
4420   if (phdrs == NULL)
4421     return FALSE;
4422
4423   maxpagesize = 1;
4424   if ((abfd->flags & D_PAGED) != 0)
4425     maxpagesize = bed->maxpagesize;
4426
4427   off = bed->s->sizeof_ehdr;
4428   off += alloc * bed->s->sizeof_phdr;
4429   if (header_pad < (bfd_vma) off)
4430     header_pad = 0;
4431   else
4432     header_pad -= off;
4433   off += header_pad;
4434
4435   for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0;
4436        m != NULL;
4437        m = m->next, p++, j++)
4438     {
4439       asection **secpp;
4440       bfd_vma off_adjust;
4441       bfd_boolean no_contents;
4442
4443       /* If elf_segment_map is not from map_sections_to_segments, the
4444          sections may not be correctly ordered.  NOTE: sorting should
4445          not be done to the PT_NOTE section of a corefile, which may
4446          contain several pseudo-sections artificially created by bfd.
4447          Sorting these pseudo-sections breaks things badly.  */
4448       if (m->count > 1
4449           && !(elf_elfheader (abfd)->e_type == ET_CORE
4450                && m->p_type == PT_NOTE))
4451         qsort (m->sections, (size_t) m->count, sizeof (asection *),
4452                elf_sort_sections);
4453
4454       /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4455          number of sections with contents contributing to both p_filesz
4456          and p_memsz, followed by a number of sections with no contents
4457          that just contribute to p_memsz.  In this loop, OFF tracks next
4458          available file offset for PT_LOAD and PT_NOTE segments.  */
4459       p->p_type = m->p_type;
4460       p->p_flags = m->p_flags;
4461
4462       if (m->count == 0)
4463         p->p_vaddr = 0;
4464       else
4465         p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
4466
4467       if (m->p_paddr_valid)
4468         p->p_paddr = m->p_paddr;
4469       else if (m->count == 0)
4470         p->p_paddr = 0;
4471       else
4472         p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
4473
4474       if (p->p_type == PT_LOAD
4475           && (abfd->flags & D_PAGED) != 0)
4476         {
4477           /* p_align in demand paged PT_LOAD segments effectively stores
4478              the maximum page size.  When copying an executable with
4479              objcopy, we set m->p_align from the input file.  Use this
4480              value for maxpagesize rather than bed->maxpagesize, which
4481              may be different.  Note that we use maxpagesize for PT_TLS
4482              segment alignment later in this function, so we are relying
4483              on at least one PT_LOAD segment appearing before a PT_TLS
4484              segment.  */
4485           if (m->p_align_valid)
4486             maxpagesize = m->p_align;
4487
4488           p->p_align = maxpagesize;
4489         }
4490       else if (m->p_align_valid)
4491         p->p_align = m->p_align;
4492       else if (m->count == 0)
4493         p->p_align = 1 << bed->s->log_file_align;
4494       else
4495         p->p_align = 0;
4496
4497       no_contents = FALSE;
4498       off_adjust = 0;
4499       if (p->p_type == PT_LOAD
4500           && m->count > 0)
4501         {
4502           bfd_size_type align;
4503           unsigned int align_power = 0;
4504
4505           if (m->p_align_valid)
4506             align = p->p_align;
4507           else
4508             {
4509               for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4510                 {
4511                   unsigned int secalign;
4512
4513                   secalign = bfd_get_section_alignment (abfd, *secpp);
4514                   if (secalign > align_power)
4515                     align_power = secalign;
4516                 }
4517               align = (bfd_size_type) 1 << align_power;
4518               if (align < maxpagesize)
4519                 align = maxpagesize;
4520             }
4521
4522           for (i = 0; i < m->count; i++)
4523             if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4524               /* If we aren't making room for this section, then
4525                  it must be SHT_NOBITS regardless of what we've
4526                  set via struct bfd_elf_special_section.  */
4527               elf_section_type (m->sections[i]) = SHT_NOBITS;
4528
4529           /* Find out whether this segment contains any loadable
4530              sections.  */
4531           no_contents = TRUE;
4532           for (i = 0; i < m->count; i++)
4533             if (elf_section_type (m->sections[i]) != SHT_NOBITS)
4534               {
4535                 no_contents = FALSE;
4536                 break;
4537               }
4538
4539           off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
4540           off += off_adjust;
4541           if (no_contents)
4542             {
4543               /* We shouldn't need to align the segment on disk since
4544                  the segment doesn't need file space, but the gABI
4545                  arguably requires the alignment and glibc ld.so
4546                  checks it.  So to comply with the alignment
4547                  requirement but not waste file space, we adjust
4548                  p_offset for just this segment.  (OFF_ADJUST is
4549                  subtracted from OFF later.)  This may put p_offset
4550                  past the end of file, but that shouldn't matter.  */
4551             }
4552           else
4553             off_adjust = 0;
4554         }
4555       /* Make sure the .dynamic section is the first section in the
4556          PT_DYNAMIC segment.  */
4557       else if (p->p_type == PT_DYNAMIC
4558                && m->count > 1
4559                && strcmp (m->sections[0]->name, ".dynamic") != 0)
4560         {
4561           _bfd_error_handler
4562             (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4563              abfd);
4564           bfd_set_error (bfd_error_bad_value);
4565           return FALSE;
4566         }
4567       /* Set the note section type to SHT_NOTE.  */
4568       else if (p->p_type == PT_NOTE)
4569         for (i = 0; i < m->count; i++)
4570           elf_section_type (m->sections[i]) = SHT_NOTE;
4571
4572       p->p_offset = 0;
4573       p->p_filesz = 0;
4574       p->p_memsz = 0;
4575
4576       if (m->includes_filehdr)
4577         {
4578           if (!m->p_flags_valid)
4579             p->p_flags |= PF_R;
4580           p->p_filesz = bed->s->sizeof_ehdr;
4581           p->p_memsz = bed->s->sizeof_ehdr;
4582           if (m->count > 0)
4583             {
4584               if (p->p_vaddr < (bfd_vma) off)
4585                 {
4586                   (*_bfd_error_handler)
4587                     (_("%B: Not enough room for program headers, try linking with -N"),
4588                      abfd);
4589                   bfd_set_error (bfd_error_bad_value);
4590                   return FALSE;
4591                 }
4592
4593               p->p_vaddr -= off;
4594               if (!m->p_paddr_valid)
4595                 p->p_paddr -= off;
4596             }
4597         }
4598
4599       if (m->includes_phdrs)
4600         {
4601           if (!m->p_flags_valid)
4602             p->p_flags |= PF_R;
4603
4604           if (!m->includes_filehdr)
4605             {
4606               p->p_offset = bed->s->sizeof_ehdr;
4607
4608               if (m->count > 0)
4609                 {
4610                   p->p_vaddr -= off - p->p_offset;
4611                   if (!m->p_paddr_valid)
4612                     p->p_paddr -= off - p->p_offset;
4613                 }
4614             }
4615
4616           p->p_filesz += alloc * bed->s->sizeof_phdr;
4617           p->p_memsz += alloc * bed->s->sizeof_phdr;
4618           if (m->count)
4619             {
4620               p->p_filesz += header_pad;
4621               p->p_memsz += header_pad;
4622             }
4623         }
4624
4625       if (p->p_type == PT_LOAD
4626           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4627         {
4628           if (!m->includes_filehdr && !m->includes_phdrs)
4629             p->p_offset = off;
4630           else
4631             {
4632               file_ptr adjust;
4633
4634               adjust = off - (p->p_offset + p->p_filesz);
4635               if (!no_contents)
4636                 p->p_filesz += adjust;
4637               p->p_memsz += adjust;
4638             }
4639         }
4640
4641       /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4642          maps.  Set filepos for sections in PT_LOAD segments, and in
4643          core files, for sections in PT_NOTE segments.
4644          assign_file_positions_for_non_load_sections will set filepos
4645          for other sections and update p_filesz for other segments.  */
4646       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4647         {
4648           asection *sec;
4649           bfd_size_type align;
4650           Elf_Internal_Shdr *this_hdr;
4651
4652           sec = *secpp;
4653           this_hdr = &elf_section_data (sec)->this_hdr;
4654           align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
4655
4656           if ((p->p_type == PT_LOAD
4657                || p->p_type == PT_TLS)
4658               && (this_hdr->sh_type != SHT_NOBITS
4659                   || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4660                       && ((this_hdr->sh_flags & SHF_TLS) == 0
4661                           || p->p_type == PT_TLS))))
4662             {
4663               bfd_vma p_start = p->p_paddr;
4664               bfd_vma p_end = p_start + p->p_memsz;
4665               bfd_vma s_start = sec->lma;
4666               bfd_vma adjust = s_start - p_end;
4667
4668               if (adjust != 0
4669                   && (s_start < p_end
4670                       || p_end < p_start))
4671                 {
4672                   (*_bfd_error_handler)
4673                     (_("%B: section %A lma %#lx adjusted to %#lx"), abfd, sec,
4674                      (unsigned long) s_start, (unsigned long) p_end);
4675                   adjust = 0;
4676                   sec->lma = p_end;
4677                 }
4678               p->p_memsz += adjust;
4679
4680               if (this_hdr->sh_type != SHT_NOBITS)
4681                 {
4682                   if (p->p_filesz + adjust < p->p_memsz)
4683                     {
4684                       /* We have a PROGBITS section following NOBITS ones.
4685                          Allocate file space for the NOBITS section(s) and
4686                          zero it.  */
4687                       adjust = p->p_memsz - p->p_filesz;
4688                       if (!write_zeros (abfd, off, adjust))
4689                         return FALSE;
4690                     }
4691                   off += adjust;
4692                   p->p_filesz += adjust;
4693                 }
4694             }
4695
4696           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4697             {
4698               /* The section at i == 0 is the one that actually contains
4699                  everything.  */
4700               if (i == 0)
4701                 {
4702                   this_hdr->sh_offset = sec->filepos = off;
4703                   off += this_hdr->sh_size;
4704                   p->p_filesz = this_hdr->sh_size;
4705                   p->p_memsz = 0;
4706                   p->p_align = 1;
4707                 }
4708               else
4709                 {
4710                   /* The rest are fake sections that shouldn't be written.  */
4711                   sec->filepos = 0;
4712                   sec->size = 0;
4713                   sec->flags = 0;
4714                   continue;
4715                 }
4716             }
4717           else
4718             {
4719               if (p->p_type == PT_LOAD)
4720                 {
4721                   this_hdr->sh_offset = sec->filepos = off;
4722                   if (this_hdr->sh_type != SHT_NOBITS)
4723                     off += this_hdr->sh_size;
4724                 }
4725               else if (this_hdr->sh_type == SHT_NOBITS
4726                        && (this_hdr->sh_flags & SHF_TLS) != 0
4727                        && this_hdr->sh_offset == 0)
4728                 {
4729                   /* This is a .tbss section that didn't get a PT_LOAD.
4730                      (See _bfd_elf_map_sections_to_segments "Create a
4731                      final PT_LOAD".)  Set sh_offset to the value it
4732                      would have if we had created a zero p_filesz and
4733                      p_memsz PT_LOAD header for the section.  This
4734                      also makes the PT_TLS header have the same
4735                      p_offset value.  */
4736                   bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr,
4737                                                           off, align);
4738                   this_hdr->sh_offset = sec->filepos = off + adjust;
4739                 }
4740
4741               if (this_hdr->sh_type != SHT_NOBITS)
4742                 {
4743                   p->p_filesz += this_hdr->sh_size;
4744                   /* A load section without SHF_ALLOC is something like
4745                      a note section in a PT_NOTE segment.  These take
4746                      file space but are not loaded into memory.  */
4747                   if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4748                     p->p_memsz += this_hdr->sh_size;
4749                 }
4750               else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4751                 {
4752                   if (p->p_type == PT_TLS)
4753                     p->p_memsz += this_hdr->sh_size;
4754
4755                   /* .tbss is special.  It doesn't contribute to p_memsz of
4756                      normal segments.  */
4757                   else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4758                     p->p_memsz += this_hdr->sh_size;
4759                 }
4760
4761               if (align > p->p_align
4762                   && !m->p_align_valid
4763                   && (p->p_type != PT_LOAD
4764                       || (abfd->flags & D_PAGED) == 0))
4765                 p->p_align = align;
4766             }
4767
4768           if (!m->p_flags_valid)
4769             {
4770               p->p_flags |= PF_R;
4771               if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4772                 p->p_flags |= PF_X;
4773               if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4774                 p->p_flags |= PF_W;
4775             }
4776         }
4777       off -= off_adjust;
4778
4779       /* Check that all sections are in a PT_LOAD segment.
4780          Don't check funky gdb generated core files.  */
4781       if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4782         {
4783           bfd_boolean check_vma = TRUE;
4784
4785           for (i = 1; i < m->count; i++)
4786             if (m->sections[i]->vma == m->sections[i - 1]->vma
4787                 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
4788                                        ->this_hdr), p) != 0
4789                 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
4790                                        ->this_hdr), p) != 0)
4791               {
4792                 /* Looks like we have overlays packed into the segment.  */
4793                 check_vma = FALSE;
4794                 break;
4795               }
4796
4797           for (i = 0; i < m->count; i++)
4798             {
4799               Elf_Internal_Shdr *this_hdr;
4800               asection *sec;
4801
4802               sec = m->sections[i];
4803               this_hdr = &(elf_section_data(sec)->this_hdr);
4804               if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
4805                   && !ELF_TBSS_SPECIAL (this_hdr, p))
4806                 {
4807                   (*_bfd_error_handler)
4808                     (_("%B: section `%A' can't be allocated in segment %d"),
4809                      abfd, sec, j);
4810                   print_segment_map (m);
4811                 }
4812             }
4813         }
4814     }
4815
4816   elf_tdata (abfd)->next_file_pos = off;
4817   return TRUE;
4818 }
4819
4820 /* Assign file positions for the other sections.  */
4821
4822 static bfd_boolean
4823 assign_file_positions_for_non_load_sections (bfd *abfd,
4824                                              struct bfd_link_info *link_info)
4825 {
4826   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4827   Elf_Internal_Shdr **i_shdrpp;
4828   Elf_Internal_Shdr **hdrpp;
4829   Elf_Internal_Phdr *phdrs;
4830   Elf_Internal_Phdr *p;
4831   struct elf_segment_map *m;
4832   struct elf_segment_map *hdrs_segment;
4833   bfd_vma filehdr_vaddr, filehdr_paddr;
4834   bfd_vma phdrs_vaddr, phdrs_paddr;
4835   file_ptr off;
4836   unsigned int num_sec;
4837   unsigned int i;
4838   unsigned int count;
4839
4840   i_shdrpp = elf_elfsections (abfd);
4841   num_sec = elf_numsections (abfd);
4842   off = elf_tdata (abfd)->next_file_pos;
4843   for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4844     {
4845       struct elf_obj_tdata *tdata = elf_tdata (abfd);
4846       Elf_Internal_Shdr *hdr;
4847
4848       hdr = *hdrpp;
4849       if (hdr->bfd_section != NULL
4850           && (hdr->bfd_section->filepos != 0
4851               || (hdr->sh_type == SHT_NOBITS
4852                   && hdr->contents == NULL)))
4853         BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4854       else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4855         {
4856           if (hdr->sh_size != 0)
4857             (*_bfd_error_handler)
4858               (_("%B: warning: allocated section `%s' not in segment"),
4859                abfd,
4860                (hdr->bfd_section == NULL
4861                 ? "*unknown*"
4862                 : hdr->bfd_section->name));
4863           /* We don't need to page align empty sections.  */
4864           if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4865             off += vma_page_aligned_bias (hdr->sh_addr, off,
4866                                           bed->maxpagesize);
4867           else
4868             off += vma_page_aligned_bias (hdr->sh_addr, off,
4869                                           hdr->sh_addralign);
4870           off = _bfd_elf_assign_file_position_for_section (hdr, off,
4871                                                            FALSE);
4872         }
4873       else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4874                 && hdr->bfd_section == NULL)
4875                || hdr == i_shdrpp[tdata->symtab_section]
4876                || hdr == i_shdrpp[tdata->symtab_shndx_section]
4877                || hdr == i_shdrpp[tdata->strtab_section])
4878         hdr->sh_offset = -1;
4879       else
4880         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4881     }
4882
4883   /* Now that we have set the section file positions, we can set up
4884      the file positions for the non PT_LOAD segments.  */
4885   count = 0;
4886   filehdr_vaddr = 0;
4887   filehdr_paddr = 0;
4888   phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4889   phdrs_paddr = 0;
4890   hdrs_segment = NULL;
4891   phdrs = elf_tdata (abfd)->phdr;
4892   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4893        m != NULL;
4894        m = m->next, p++)
4895     {
4896       ++count;
4897       if (p->p_type != PT_LOAD)
4898         continue;
4899
4900       if (m->includes_filehdr)
4901         {
4902           filehdr_vaddr = p->p_vaddr;
4903           filehdr_paddr = p->p_paddr;
4904         }
4905       if (m->includes_phdrs)
4906         {
4907           phdrs_vaddr = p->p_vaddr;
4908           phdrs_paddr = p->p_paddr;
4909           if (m->includes_filehdr)
4910             {
4911               hdrs_segment = m;
4912               phdrs_vaddr += bed->s->sizeof_ehdr;
4913               phdrs_paddr += bed->s->sizeof_ehdr;
4914             }
4915         }
4916     }
4917
4918   if (hdrs_segment != NULL && link_info != NULL)
4919     {
4920       /* There is a segment that contains both the file headers and the
4921          program headers, so provide a symbol __ehdr_start pointing there.
4922          A program can use this to examine itself robustly.  */
4923
4924       struct elf_link_hash_entry *hash
4925         = elf_link_hash_lookup (elf_hash_table (link_info), "__ehdr_start",
4926                                 FALSE, FALSE, TRUE);
4927       /* If the symbol was referenced and not defined, define it.  */
4928       if (hash != NULL
4929           && (hash->root.type == bfd_link_hash_new
4930               || hash->root.type == bfd_link_hash_undefined
4931               || hash->root.type == bfd_link_hash_undefweak
4932               || hash->root.type == bfd_link_hash_common))
4933         {
4934           asection *s = NULL;
4935           if (hdrs_segment->count != 0)
4936             /* The segment contains sections, so use the first one.  */
4937             s = hdrs_segment->sections[0];
4938           else
4939             /* Use the first (i.e. lowest-addressed) section in any segment.  */
4940             for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4941               if (m->count != 0)
4942                 {
4943                   s = m->sections[0];
4944                   break;
4945                 }
4946
4947           if (s != NULL)
4948             {
4949               hash->root.u.def.value = filehdr_vaddr - s->vma;
4950               hash->root.u.def.section = s;
4951             }
4952           else
4953             {
4954               hash->root.u.def.value = filehdr_vaddr;
4955               hash->root.u.def.section = bfd_abs_section_ptr;
4956             }
4957
4958           hash->root.type = bfd_link_hash_defined;
4959           hash->def_regular = 1;
4960           hash->non_elf = 0;
4961         }
4962     }
4963
4964   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4965        m != NULL;
4966        m = m->next, p++)
4967     {
4968       if (p->p_type == PT_GNU_RELRO)
4969         {
4970           const Elf_Internal_Phdr *lp;
4971           struct elf_segment_map *lm;
4972
4973           if (link_info != NULL)
4974             {
4975               /* During linking the range of the RELRO segment is passed
4976                  in link_info.  */
4977               for (lm = elf_tdata (abfd)->segment_map, lp = phdrs;
4978                    lm != NULL;
4979                    lm = lm->next, lp++)
4980                 {
4981                   if (lp->p_type == PT_LOAD
4982                       && lp->p_vaddr < link_info->relro_end
4983                       && lp->p_vaddr + lp->p_filesz >= link_info->relro_end
4984                       && lm->count != 0
4985                       && lm->sections[0]->vma >= link_info->relro_start)
4986                     break;
4987                 }
4988
4989               /* PR ld/14207.  If the RELRO segment doesn't fit in the
4990                  LOAD segment, it should be removed.  */
4991               BFD_ASSERT (lm != NULL);
4992             }
4993           else
4994             {
4995               /* Otherwise we are copying an executable or shared
4996                  library, but we need to use the same linker logic.  */
4997               for (lp = phdrs; lp < phdrs + count; ++lp)
4998                 {
4999                   if (lp->p_type == PT_LOAD
5000                       && lp->p_paddr == p->p_paddr)
5001                     break;
5002                 }
5003             }
5004
5005           if (lp < phdrs + count)
5006             {
5007               p->p_vaddr = lp->p_vaddr;
5008               p->p_paddr = lp->p_paddr;
5009               p->p_offset = lp->p_offset;
5010               if (link_info != NULL)
5011                 p->p_filesz = link_info->relro_end - lp->p_vaddr;
5012               else if (m->p_size_valid)
5013                 p->p_filesz = m->p_size;
5014               else
5015                 abort ();
5016               p->p_memsz = p->p_filesz;
5017               /* Preserve the alignment and flags if they are valid. The
5018                  gold linker generates RW/4 for the PT_GNU_RELRO section.
5019                  It is better for objcopy/strip to honor these attributes
5020                  otherwise gdb will choke when using separate debug files.
5021                */
5022               if (!m->p_align_valid)
5023                 p->p_align = 1;
5024               if (!m->p_flags_valid)
5025                 p->p_flags = (lp->p_flags & ~PF_W);
5026             }
5027           else
5028             {
5029               memset (p, 0, sizeof *p);
5030               p->p_type = PT_NULL;
5031             }
5032         }
5033       else if (p->p_type == PT_GNU_STACK)
5034         {
5035           if (m->p_size_valid)
5036             p->p_memsz = m->p_size;
5037         }
5038       else if (m->count != 0)
5039         {
5040           if (p->p_type != PT_LOAD
5041               && (p->p_type != PT_NOTE
5042                   || bfd_get_format (abfd) != bfd_core))
5043             {
5044               BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
5045
5046               p->p_filesz = 0;
5047               p->p_offset = m->sections[0]->filepos;
5048               for (i = m->count; i-- != 0;)
5049                 {
5050                   asection *sect = m->sections[i];
5051                   Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
5052                   if (hdr->sh_type != SHT_NOBITS)
5053                     {
5054                       p->p_filesz = (sect->filepos - m->sections[0]->filepos
5055                                      + hdr->sh_size);
5056                       break;
5057                     }
5058                 }
5059             }
5060         }
5061       else if (m->includes_filehdr)
5062         {
5063           p->p_vaddr = filehdr_vaddr;
5064           if (! m->p_paddr_valid)
5065             p->p_paddr = filehdr_paddr;
5066         }
5067       else if (m->includes_phdrs)
5068         {
5069           p->p_vaddr = phdrs_vaddr;
5070           if (! m->p_paddr_valid)
5071             p->p_paddr = phdrs_paddr;
5072         }
5073     }
5074
5075   elf_tdata (abfd)->next_file_pos = off;
5076
5077   return TRUE;
5078 }
5079
5080 /* Work out the file positions of all the sections.  This is called by
5081    _bfd_elf_compute_section_file_positions.  All the section sizes and
5082    VMAs must be known before this is called.
5083
5084    Reloc sections come in two flavours: Those processed specially as
5085    "side-channel" data attached to a section to which they apply, and
5086    those that bfd doesn't process as relocations.  The latter sort are
5087    stored in a normal bfd section by bfd_section_from_shdr.   We don't
5088    consider the former sort here, unless they form part of the loadable
5089    image.  Reloc sections not assigned here will be handled later by
5090    assign_file_positions_for_relocs.
5091
5092    We also don't set the positions of the .symtab and .strtab here.  */
5093
5094 static bfd_boolean
5095 assign_file_positions_except_relocs (bfd *abfd,
5096                                      struct bfd_link_info *link_info)
5097 {
5098   struct elf_obj_tdata *tdata = elf_tdata (abfd);
5099   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5100   file_ptr off;
5101   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5102
5103   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
5104       && bfd_get_format (abfd) != bfd_core)
5105     {
5106       Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
5107       unsigned int num_sec = elf_numsections (abfd);
5108       Elf_Internal_Shdr **hdrpp;
5109       unsigned int i;
5110
5111       /* Start after the ELF header.  */
5112       off = i_ehdrp->e_ehsize;
5113
5114       /* We are not creating an executable, which means that we are
5115          not creating a program header, and that the actual order of
5116          the sections in the file is unimportant.  */
5117       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
5118         {
5119           Elf_Internal_Shdr *hdr;
5120
5121           hdr = *hdrpp;
5122           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5123                && hdr->bfd_section == NULL)
5124               || i == tdata->symtab_section
5125               || i == tdata->symtab_shndx_section
5126               || i == tdata->strtab_section)
5127             {
5128               hdr->sh_offset = -1;
5129             }
5130           else
5131             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5132         }
5133     }
5134   else
5135     {
5136       unsigned int alloc;
5137
5138       /* Assign file positions for the loaded sections based on the
5139          assignment of sections to segments.  */
5140       if (!assign_file_positions_for_load_sections (abfd, link_info))
5141         return FALSE;
5142
5143       /* And for non-load sections.  */
5144       if (!assign_file_positions_for_non_load_sections (abfd, link_info))
5145         return FALSE;
5146
5147       if (bed->elf_backend_modify_program_headers != NULL)
5148         {
5149           if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
5150             return FALSE;
5151         }
5152
5153       /* Write out the program headers.  */
5154       alloc = tdata->program_header_size / bed->s->sizeof_phdr;
5155       if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
5156           || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
5157         return FALSE;
5158
5159       off = tdata->next_file_pos;
5160     }
5161
5162   /* Place the section headers.  */
5163   off = align_file_position (off, 1 << bed->s->log_file_align);
5164   i_ehdrp->e_shoff = off;
5165   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
5166
5167   tdata->next_file_pos = off;
5168
5169   return TRUE;
5170 }
5171
5172 static bfd_boolean
5173 prep_headers (bfd *abfd)
5174 {
5175   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form.  */
5176   struct elf_strtab_hash *shstrtab;
5177   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5178
5179   i_ehdrp = elf_elfheader (abfd);
5180
5181   shstrtab = _bfd_elf_strtab_init ();
5182   if (shstrtab == NULL)
5183     return FALSE;
5184
5185   elf_shstrtab (abfd) = shstrtab;
5186
5187   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
5188   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
5189   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
5190   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
5191
5192   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
5193   i_ehdrp->e_ident[EI_DATA] =
5194     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
5195   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
5196
5197   if ((abfd->flags & DYNAMIC) != 0)
5198     i_ehdrp->e_type = ET_DYN;
5199   else if ((abfd->flags & EXEC_P) != 0)
5200     i_ehdrp->e_type = ET_EXEC;
5201   else if (bfd_get_format (abfd) == bfd_core)
5202     i_ehdrp->e_type = ET_CORE;
5203   else
5204     i_ehdrp->e_type = ET_REL;
5205
5206   switch (bfd_get_arch (abfd))
5207     {
5208     case bfd_arch_unknown:
5209       i_ehdrp->e_machine = EM_NONE;
5210       break;
5211
5212       /* There used to be a long list of cases here, each one setting
5213          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5214          in the corresponding bfd definition.  To avoid duplication,
5215          the switch was removed.  Machines that need special handling
5216          can generally do it in elf_backend_final_write_processing(),
5217          unless they need the information earlier than the final write.
5218          Such need can generally be supplied by replacing the tests for
5219          e_machine with the conditions used to determine it.  */
5220     default:
5221       i_ehdrp->e_machine = bed->elf_machine_code;
5222     }
5223
5224   i_ehdrp->e_version = bed->s->ev_current;
5225   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
5226
5227   /* No program header, for now.  */
5228   i_ehdrp->e_phoff = 0;
5229   i_ehdrp->e_phentsize = 0;
5230   i_ehdrp->e_phnum = 0;
5231
5232   /* Each bfd section is section header entry.  */
5233   i_ehdrp->e_entry = bfd_get_start_address (abfd);
5234   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
5235
5236   /* If we're building an executable, we'll need a program header table.  */
5237   if (abfd->flags & EXEC_P)
5238     /* It all happens later.  */
5239     ;
5240   else
5241     {
5242       i_ehdrp->e_phentsize = 0;
5243       i_ehdrp->e_phoff = 0;
5244     }
5245
5246   elf_tdata (abfd)->symtab_hdr.sh_name =
5247     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
5248   elf_tdata (abfd)->strtab_hdr.sh_name =
5249     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
5250   elf_tdata (abfd)->shstrtab_hdr.sh_name =
5251     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
5252   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5253       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5254       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
5255     return FALSE;
5256
5257   return TRUE;
5258 }
5259
5260 /* Assign file positions for all the reloc sections which are not part
5261    of the loadable file image.  */
5262
5263 void
5264 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
5265 {
5266   file_ptr off;
5267   unsigned int i, num_sec;
5268   Elf_Internal_Shdr **shdrpp;
5269
5270   off = elf_tdata (abfd)->next_file_pos;
5271
5272   num_sec = elf_numsections (abfd);
5273   for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
5274     {
5275       Elf_Internal_Shdr *shdrp;
5276
5277       shdrp = *shdrpp;
5278       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
5279           && shdrp->sh_offset == -1)
5280         off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
5281     }
5282
5283   elf_tdata (abfd)->next_file_pos = off;
5284 }
5285
5286 bfd_boolean
5287 _bfd_elf_write_object_contents (bfd *abfd)
5288 {
5289   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5290   Elf_Internal_Shdr **i_shdrp;
5291   bfd_boolean failed;
5292   unsigned int count, num_sec;
5293
5294   if (! abfd->output_has_begun
5295       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
5296     return FALSE;
5297
5298   i_shdrp = elf_elfsections (abfd);
5299
5300   failed = FALSE;
5301   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
5302   if (failed)
5303     return FALSE;
5304
5305   _bfd_elf_assign_file_positions_for_relocs (abfd);
5306
5307   /* After writing the headers, we need to write the sections too...  */
5308   num_sec = elf_numsections (abfd);
5309   for (count = 1; count < num_sec; count++)
5310     {
5311       if (bed->elf_backend_section_processing)
5312         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
5313       if (i_shdrp[count]->contents)
5314         {
5315           bfd_size_type amt = i_shdrp[count]->sh_size;
5316
5317           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
5318               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
5319             return FALSE;
5320         }
5321     }
5322
5323   /* Write out the section header names.  */
5324   if (elf_shstrtab (abfd) != NULL
5325       && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
5326           || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
5327     return FALSE;
5328
5329   if (bed->elf_backend_final_write_processing)
5330     (*bed->elf_backend_final_write_processing) (abfd,
5331                                                 elf_tdata (abfd)->linker);
5332
5333   if (!bed->s->write_shdrs_and_ehdr (abfd))
5334     return FALSE;
5335
5336   /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0].  */
5337   if (elf_tdata (abfd)->after_write_object_contents)
5338     return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
5339
5340   return TRUE;
5341 }
5342
5343 bfd_boolean
5344 _bfd_elf_write_corefile_contents (bfd *abfd)
5345 {
5346   /* Hopefully this can be done just like an object file.  */
5347   return _bfd_elf_write_object_contents (abfd);
5348 }
5349
5350 /* Given a section, search the header to find them.  */
5351
5352 unsigned int
5353 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
5354 {
5355   const struct elf_backend_data *bed;
5356   unsigned int sec_index;
5357
5358   if (elf_section_data (asect) != NULL
5359       && elf_section_data (asect)->this_idx != 0)
5360     return elf_section_data (asect)->this_idx;
5361
5362   if (bfd_is_abs_section (asect))
5363     sec_index = SHN_ABS;
5364   else if (bfd_is_com_section (asect))
5365     sec_index = SHN_COMMON;
5366   else if (bfd_is_und_section (asect))
5367     sec_index = SHN_UNDEF;
5368   else
5369     sec_index = SHN_BAD;
5370
5371   bed = get_elf_backend_data (abfd);
5372   if (bed->elf_backend_section_from_bfd_section)
5373     {
5374       int retval = sec_index;
5375
5376       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5377         return retval;
5378     }
5379
5380   if (sec_index == SHN_BAD)
5381     bfd_set_error (bfd_error_nonrepresentable_section);
5382
5383   return sec_index;
5384 }
5385
5386 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5387    on error.  */
5388
5389 int
5390 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
5391 {
5392   asymbol *asym_ptr = *asym_ptr_ptr;
5393   int idx;
5394   flagword flags = asym_ptr->flags;
5395
5396   /* When gas creates relocations against local labels, it creates its
5397      own symbol for the section, but does put the symbol into the
5398      symbol chain, so udata is 0.  When the linker is generating
5399      relocatable output, this section symbol may be for one of the
5400      input sections rather than the output section.  */
5401   if (asym_ptr->udata.i == 0
5402       && (flags & BSF_SECTION_SYM)
5403       && asym_ptr->section)
5404     {
5405       asection *sec;
5406       int indx;
5407
5408       sec = asym_ptr->section;
5409       if (sec->owner != abfd && sec->output_section != NULL)
5410         sec = sec->output_section;
5411       if (sec->owner == abfd
5412           && (indx = sec->index) < elf_num_section_syms (abfd)
5413           && elf_section_syms (abfd)[indx] != NULL)
5414         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5415     }
5416
5417   idx = asym_ptr->udata.i;
5418
5419   if (idx == 0)
5420     {
5421       /* This case can occur when using --strip-symbol on a symbol
5422          which is used in a relocation entry.  */
5423       (*_bfd_error_handler)
5424         (_("%B: symbol `%s' required but not present"),
5425          abfd, bfd_asymbol_name (asym_ptr));
5426       bfd_set_error (bfd_error_no_symbols);
5427       return -1;
5428     }
5429
5430 #if DEBUG & 4
5431   {
5432     fprintf (stderr,
5433              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
5434              (long) asym_ptr, asym_ptr->name, idx, (long) flags);
5435     fflush (stderr);
5436   }
5437 #endif
5438
5439   return idx;
5440 }
5441
5442 /* Rewrite program header information.  */
5443
5444 static bfd_boolean
5445 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5446 {
5447   Elf_Internal_Ehdr *iehdr;
5448   struct elf_segment_map *map;
5449   struct elf_segment_map *map_first;
5450   struct elf_segment_map **pointer_to_map;
5451   Elf_Internal_Phdr *segment;
5452   asection *section;
5453   unsigned int i;
5454   unsigned int num_segments;
5455   bfd_boolean phdr_included = FALSE;
5456   bfd_boolean p_paddr_valid;
5457   bfd_vma maxpagesize;
5458   struct elf_segment_map *phdr_adjust_seg = NULL;
5459   unsigned int phdr_adjust_num = 0;
5460   const struct elf_backend_data *bed;
5461
5462   bed = get_elf_backend_data (ibfd);
5463   iehdr = elf_elfheader (ibfd);
5464
5465   map_first = NULL;
5466   pointer_to_map = &map_first;
5467
5468   num_segments = elf_elfheader (ibfd)->e_phnum;
5469   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5470
5471   /* Returns the end address of the segment + 1.  */
5472 #define SEGMENT_END(segment, start)                                     \
5473   (start + (segment->p_memsz > segment->p_filesz                        \
5474             ? segment->p_memsz : segment->p_filesz))
5475
5476 #define SECTION_SIZE(section, segment)                                  \
5477   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
5478     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
5479    ? section->size : 0)
5480
5481   /* Returns TRUE if the given section is contained within
5482      the given segment.  VMA addresses are compared.  */
5483 #define IS_CONTAINED_BY_VMA(section, segment)                           \
5484   (section->vma >= segment->p_vaddr                                     \
5485    && (section->vma + SECTION_SIZE (section, segment)                   \
5486        <= (SEGMENT_END (segment, segment->p_vaddr))))
5487
5488   /* Returns TRUE if the given section is contained within
5489      the given segment.  LMA addresses are compared.  */
5490 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
5491   (section->lma >= base                                                 \
5492    && (section->lma + SECTION_SIZE (section, segment)                   \
5493        <= SEGMENT_END (segment, base)))
5494
5495   /* Handle PT_NOTE segment.  */
5496 #define IS_NOTE(p, s)                                                   \
5497   (p->p_type == PT_NOTE                                                 \
5498    && elf_section_type (s) == SHT_NOTE                                  \
5499    && (bfd_vma) s->filepos >= p->p_offset                               \
5500    && ((bfd_vma) s->filepos + s->size                                   \
5501        <= p->p_offset + p->p_filesz))
5502
5503   /* Special case: corefile "NOTE" section containing regs, prpsinfo
5504      etc.  */
5505 #define IS_COREFILE_NOTE(p, s)                                          \
5506   (IS_NOTE (p, s)                                                       \
5507    && bfd_get_format (ibfd) == bfd_core                                 \
5508    && s->vma == 0                                                       \
5509    && s->lma == 0)
5510
5511   /* The complicated case when p_vaddr is 0 is to handle the Solaris
5512      linker, which generates a PT_INTERP section with p_vaddr and
5513      p_memsz set to 0.  */
5514 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
5515   (p->p_vaddr == 0                                                      \
5516    && p->p_paddr == 0                                                   \
5517    && p->p_memsz == 0                                                   \
5518    && p->p_filesz > 0                                                   \
5519    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
5520    && s->size > 0                                                       \
5521    && (bfd_vma) s->filepos >= p->p_offset                               \
5522    && ((bfd_vma) s->filepos + s->size                                   \
5523        <= p->p_offset + p->p_filesz))
5524
5525   /* Decide if the given section should be included in the given segment.
5526      A section will be included if:
5527        1. It is within the address space of the segment -- we use the LMA
5528           if that is set for the segment and the VMA otherwise,
5529        2. It is an allocated section or a NOTE section in a PT_NOTE
5530           segment.
5531        3. There is an output section associated with it,
5532        4. The section has not already been allocated to a previous segment.
5533        5. PT_GNU_STACK segments do not include any sections.
5534        6. PT_TLS segment includes only SHF_TLS sections.
5535        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5536        8. PT_DYNAMIC should not contain empty sections at the beginning
5537           (with the possible exception of .dynamic).  */
5538 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed)              \
5539   ((((segment->p_paddr                                                  \
5540       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
5541       : IS_CONTAINED_BY_VMA (section, segment))                         \
5542      && (section->flags & SEC_ALLOC) != 0)                              \
5543     || IS_NOTE (segment, section))                                      \
5544    && segment->p_type != PT_GNU_STACK                                   \
5545    && (segment->p_type != PT_TLS                                        \
5546        || (section->flags & SEC_THREAD_LOCAL))                          \
5547    && (segment->p_type == PT_LOAD                                       \
5548        || segment->p_type == PT_TLS                                     \
5549        || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
5550    && (segment->p_type != PT_DYNAMIC                                    \
5551        || SECTION_SIZE (section, segment) > 0                           \
5552        || (segment->p_paddr                                             \
5553            ? segment->p_paddr != section->lma                           \
5554            : segment->p_vaddr != section->vma)                          \
5555        || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic")    \
5556            == 0))                                                       \
5557    && !section->segment_mark)
5558
5559 /* If the output section of a section in the input segment is NULL,
5560    it is removed from the corresponding output segment.   */
5561 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
5562   (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed)          \
5563    && section->output_section != NULL)
5564
5565   /* Returns TRUE iff seg1 starts after the end of seg2.  */
5566 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
5567   (seg1->field >= SEGMENT_END (seg2, seg2->field))
5568
5569   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5570      their VMA address ranges and their LMA address ranges overlap.
5571      It is possible to have overlapping VMA ranges without overlapping LMA
5572      ranges.  RedBoot images for example can have both .data and .bss mapped
5573      to the same VMA range, but with the .data section mapped to a different
5574      LMA.  */
5575 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
5576   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
5577         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
5578    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
5579         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5580
5581   /* Initialise the segment mark field.  */
5582   for (section = ibfd->sections; section != NULL; section = section->next)
5583     section->segment_mark = FALSE;
5584
5585   /* The Solaris linker creates program headers in which all the
5586      p_paddr fields are zero.  When we try to objcopy or strip such a
5587      file, we get confused.  Check for this case, and if we find it
5588      don't set the p_paddr_valid fields.  */
5589   p_paddr_valid = FALSE;
5590   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5591        i < num_segments;
5592        i++, segment++)
5593     if (segment->p_paddr != 0)
5594       {
5595         p_paddr_valid = TRUE;
5596         break;
5597       }
5598
5599   /* Scan through the segments specified in the program header
5600      of the input BFD.  For this first scan we look for overlaps
5601      in the loadable segments.  These can be created by weird
5602      parameters to objcopy.  Also, fix some solaris weirdness.  */
5603   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5604        i < num_segments;
5605        i++, segment++)
5606     {
5607       unsigned int j;
5608       Elf_Internal_Phdr *segment2;
5609
5610       if (segment->p_type == PT_INTERP)
5611         for (section = ibfd->sections; section; section = section->next)
5612           if (IS_SOLARIS_PT_INTERP (segment, section))
5613             {
5614               /* Mininal change so that the normal section to segment
5615                  assignment code will work.  */
5616               segment->p_vaddr = section->vma;
5617               break;
5618             }
5619
5620       if (segment->p_type != PT_LOAD)
5621         {
5622           /* Remove PT_GNU_RELRO segment.  */
5623           if (segment->p_type == PT_GNU_RELRO)
5624             segment->p_type = PT_NULL;
5625           continue;
5626         }
5627
5628       /* Determine if this segment overlaps any previous segments.  */
5629       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
5630         {
5631           bfd_signed_vma extra_length;
5632
5633           if (segment2->p_type != PT_LOAD
5634               || !SEGMENT_OVERLAPS (segment, segment2))
5635             continue;
5636
5637           /* Merge the two segments together.  */
5638           if (segment2->p_vaddr < segment->p_vaddr)
5639             {
5640               /* Extend SEGMENT2 to include SEGMENT and then delete
5641                  SEGMENT.  */
5642               extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5643                               - SEGMENT_END (segment2, segment2->p_vaddr));
5644
5645               if (extra_length > 0)
5646                 {
5647                   segment2->p_memsz += extra_length;
5648                   segment2->p_filesz += extra_length;
5649                 }
5650
5651               segment->p_type = PT_NULL;
5652
5653               /* Since we have deleted P we must restart the outer loop.  */
5654               i = 0;
5655               segment = elf_tdata (ibfd)->phdr;
5656               break;
5657             }
5658           else
5659             {
5660               /* Extend SEGMENT to include SEGMENT2 and then delete
5661                  SEGMENT2.  */
5662               extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5663                               - SEGMENT_END (segment, segment->p_vaddr));
5664
5665               if (extra_length > 0)
5666                 {
5667                   segment->p_memsz += extra_length;
5668                   segment->p_filesz += extra_length;
5669                 }
5670
5671               segment2->p_type = PT_NULL;
5672             }
5673         }
5674     }
5675
5676   /* The second scan attempts to assign sections to segments.  */
5677   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5678        i < num_segments;
5679        i++, segment++)
5680     {
5681       unsigned int section_count;
5682       asection **sections;
5683       asection *output_section;
5684       unsigned int isec;
5685       bfd_vma matching_lma;
5686       bfd_vma suggested_lma;
5687       unsigned int j;
5688       bfd_size_type amt;
5689       asection *first_section;
5690       bfd_boolean first_matching_lma;
5691       bfd_boolean first_suggested_lma;
5692
5693       if (segment->p_type == PT_NULL)
5694         continue;
5695
5696       first_section = NULL;
5697       /* Compute how many sections might be placed into this segment.  */
5698       for (section = ibfd->sections, section_count = 0;
5699            section != NULL;
5700            section = section->next)
5701         {
5702           /* Find the first section in the input segment, which may be
5703              removed from the corresponding output segment.   */
5704           if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5705             {
5706               if (first_section == NULL)
5707                 first_section = section;
5708               if (section->output_section != NULL)
5709                 ++section_count;
5710             }
5711         }
5712
5713       /* Allocate a segment map big enough to contain
5714          all of the sections we have selected.  */
5715       amt = sizeof (struct elf_segment_map);
5716       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5717       map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
5718       if (map == NULL)
5719         return FALSE;
5720
5721       /* Initialise the fields of the segment map.  Default to
5722          using the physical address of the segment in the input BFD.  */
5723       map->next = NULL;
5724       map->p_type = segment->p_type;
5725       map->p_flags = segment->p_flags;
5726       map->p_flags_valid = 1;
5727
5728       /* If the first section in the input segment is removed, there is
5729          no need to preserve segment physical address in the corresponding
5730          output segment.  */
5731       if (!first_section || first_section->output_section != NULL)
5732         {
5733           map->p_paddr = segment->p_paddr;
5734           map->p_paddr_valid = p_paddr_valid;
5735         }
5736
5737       /* Determine if this segment contains the ELF file header
5738          and if it contains the program headers themselves.  */
5739       map->includes_filehdr = (segment->p_offset == 0
5740                                && segment->p_filesz >= iehdr->e_ehsize);
5741       map->includes_phdrs = 0;
5742
5743       if (!phdr_included || segment->p_type != PT_LOAD)
5744         {
5745           map->includes_phdrs =
5746             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5747              && (segment->p_offset + segment->p_filesz
5748                  >= ((bfd_vma) iehdr->e_phoff
5749                      + iehdr->e_phnum * iehdr->e_phentsize)));
5750
5751           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5752             phdr_included = TRUE;
5753         }
5754
5755       if (section_count == 0)
5756         {
5757           /* Special segments, such as the PT_PHDR segment, may contain
5758              no sections, but ordinary, loadable segments should contain
5759              something.  They are allowed by the ELF spec however, so only
5760              a warning is produced.  */
5761           if (segment->p_type == PT_LOAD)
5762             (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5763                                      " detected, is this intentional ?\n"),
5764                                    ibfd);
5765
5766           map->count = 0;
5767           *pointer_to_map = map;
5768           pointer_to_map = &map->next;
5769
5770           continue;
5771         }
5772
5773       /* Now scan the sections in the input BFD again and attempt
5774          to add their corresponding output sections to the segment map.
5775          The problem here is how to handle an output section which has
5776          been moved (ie had its LMA changed).  There are four possibilities:
5777
5778          1. None of the sections have been moved.
5779             In this case we can continue to use the segment LMA from the
5780             input BFD.
5781
5782          2. All of the sections have been moved by the same amount.
5783             In this case we can change the segment's LMA to match the LMA
5784             of the first section.
5785
5786          3. Some of the sections have been moved, others have not.
5787             In this case those sections which have not been moved can be
5788             placed in the current segment which will have to have its size,
5789             and possibly its LMA changed, and a new segment or segments will
5790             have to be created to contain the other sections.
5791
5792          4. The sections have been moved, but not by the same amount.
5793             In this case we can change the segment's LMA to match the LMA
5794             of the first section and we will have to create a new segment
5795             or segments to contain the other sections.
5796
5797          In order to save time, we allocate an array to hold the section
5798          pointers that we are interested in.  As these sections get assigned
5799          to a segment, they are removed from this array.  */
5800
5801       sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
5802       if (sections == NULL)
5803         return FALSE;
5804
5805       /* Step One: Scan for segment vs section LMA conflicts.
5806          Also add the sections to the section array allocated above.
5807          Also add the sections to the current segment.  In the common
5808          case, where the sections have not been moved, this means that
5809          we have completely filled the segment, and there is nothing
5810          more to do.  */
5811       isec = 0;
5812       matching_lma = 0;
5813       suggested_lma = 0;
5814       first_matching_lma = TRUE;
5815       first_suggested_lma = TRUE;
5816
5817       for (section = ibfd->sections;
5818            section != NULL;
5819            section = section->next)
5820         if (section == first_section)
5821           break;
5822
5823       for (j = 0; section != NULL; section = section->next)
5824         {
5825           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5826             {
5827               output_section = section->output_section;
5828
5829               sections[j++] = section;
5830
5831               /* The Solaris native linker always sets p_paddr to 0.
5832                  We try to catch that case here, and set it to the
5833                  correct value.  Note - some backends require that
5834                  p_paddr be left as zero.  */
5835               if (!p_paddr_valid
5836                   && segment->p_vaddr != 0
5837                   && !bed->want_p_paddr_set_to_zero
5838                   && isec == 0
5839                   && output_section->lma != 0
5840                   && output_section->vma == (segment->p_vaddr
5841                                              + (map->includes_filehdr
5842                                                 ? iehdr->e_ehsize
5843                                                 : 0)
5844                                              + (map->includes_phdrs
5845                                                 ? (iehdr->e_phnum
5846                                                    * iehdr->e_phentsize)
5847                                                 : 0)))
5848                 map->p_paddr = segment->p_vaddr;
5849
5850               /* Match up the physical address of the segment with the
5851                  LMA address of the output section.  */
5852               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5853                   || IS_COREFILE_NOTE (segment, section)
5854                   || (bed->want_p_paddr_set_to_zero
5855                       && IS_CONTAINED_BY_VMA (output_section, segment)))
5856                 {
5857                   if (first_matching_lma || output_section->lma < matching_lma)
5858                     {
5859                       matching_lma = output_section->lma;
5860                       first_matching_lma = FALSE;
5861                     }
5862
5863                   /* We assume that if the section fits within the segment
5864                      then it does not overlap any other section within that
5865                      segment.  */
5866                   map->sections[isec++] = output_section;
5867                 }
5868               else if (first_suggested_lma)
5869                 {
5870                   suggested_lma = output_section->lma;
5871                   first_suggested_lma = FALSE;
5872                 }
5873
5874               if (j == section_count)
5875                 break;
5876             }
5877         }
5878
5879       BFD_ASSERT (j == section_count);
5880
5881       /* Step Two: Adjust the physical address of the current segment,
5882          if necessary.  */
5883       if (isec == section_count)
5884         {
5885           /* All of the sections fitted within the segment as currently
5886              specified.  This is the default case.  Add the segment to
5887              the list of built segments and carry on to process the next
5888              program header in the input BFD.  */
5889           map->count = section_count;
5890           *pointer_to_map = map;
5891           pointer_to_map = &map->next;
5892
5893           if (p_paddr_valid
5894               && !bed->want_p_paddr_set_to_zero
5895               && matching_lma != map->p_paddr
5896               && !map->includes_filehdr
5897               && !map->includes_phdrs)
5898             /* There is some padding before the first section in the
5899                segment.  So, we must account for that in the output
5900                segment's vma.  */
5901             map->p_vaddr_offset = matching_lma - map->p_paddr;
5902
5903           free (sections);
5904           continue;
5905         }
5906       else
5907         {
5908           if (!first_matching_lma)
5909             {
5910               /* At least one section fits inside the current segment.
5911                  Keep it, but modify its physical address to match the
5912                  LMA of the first section that fitted.  */
5913               map->p_paddr = matching_lma;
5914             }
5915           else
5916             {
5917               /* None of the sections fitted inside the current segment.
5918                  Change the current segment's physical address to match
5919                  the LMA of the first section.  */
5920               map->p_paddr = suggested_lma;
5921             }
5922
5923           /* Offset the segment physical address from the lma
5924              to allow for space taken up by elf headers.  */
5925           if (map->includes_filehdr)
5926             {
5927               if (map->p_paddr >= iehdr->e_ehsize)
5928                 map->p_paddr -= iehdr->e_ehsize;
5929               else
5930                 {
5931                   map->includes_filehdr = FALSE;
5932                   map->includes_phdrs = FALSE;
5933                 }
5934             }
5935
5936           if (map->includes_phdrs)
5937             {
5938               if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
5939                 {
5940                   map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5941
5942                   /* iehdr->e_phnum is just an estimate of the number
5943                      of program headers that we will need.  Make a note
5944                      here of the number we used and the segment we chose
5945                      to hold these headers, so that we can adjust the
5946                      offset when we know the correct value.  */
5947                   phdr_adjust_num = iehdr->e_phnum;
5948                   phdr_adjust_seg = map;
5949                 }
5950               else
5951                 map->includes_phdrs = FALSE;
5952             }
5953         }
5954
5955       /* Step Three: Loop over the sections again, this time assigning
5956          those that fit to the current segment and removing them from the
5957          sections array; but making sure not to leave large gaps.  Once all
5958          possible sections have been assigned to the current segment it is
5959          added to the list of built segments and if sections still remain
5960          to be assigned, a new segment is constructed before repeating
5961          the loop.  */
5962       isec = 0;
5963       do
5964         {
5965           map->count = 0;
5966           suggested_lma = 0;
5967           first_suggested_lma = TRUE;
5968
5969           /* Fill the current segment with sections that fit.  */
5970           for (j = 0; j < section_count; j++)
5971             {
5972               section = sections[j];
5973
5974               if (section == NULL)
5975                 continue;
5976
5977               output_section = section->output_section;
5978
5979               BFD_ASSERT (output_section != NULL);
5980
5981               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5982                   || IS_COREFILE_NOTE (segment, section))
5983                 {
5984                   if (map->count == 0)
5985                     {
5986                       /* If the first section in a segment does not start at
5987                          the beginning of the segment, then something is
5988                          wrong.  */
5989                       if (output_section->lma
5990                           != (map->p_paddr
5991                               + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5992                               + (map->includes_phdrs
5993                                  ? iehdr->e_phnum * iehdr->e_phentsize
5994                                  : 0)))
5995                         abort ();
5996                     }
5997                   else
5998                     {
5999                       asection *prev_sec;
6000
6001                       prev_sec = map->sections[map->count - 1];
6002
6003                       /* If the gap between the end of the previous section
6004                          and the start of this section is more than
6005                          maxpagesize then we need to start a new segment.  */
6006                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
6007                                       maxpagesize)
6008                            < BFD_ALIGN (output_section->lma, maxpagesize))
6009                           || (prev_sec->lma + prev_sec->size
6010                               > output_section->lma))
6011                         {
6012                           if (first_suggested_lma)
6013                             {
6014                               suggested_lma = output_section->lma;
6015                               first_suggested_lma = FALSE;
6016                             }
6017
6018                           continue;
6019                         }
6020                     }
6021
6022                   map->sections[map->count++] = output_section;
6023                   ++isec;
6024                   sections[j] = NULL;
6025                   section->segment_mark = TRUE;
6026                 }
6027               else if (first_suggested_lma)
6028                 {
6029                   suggested_lma = output_section->lma;
6030                   first_suggested_lma = FALSE;
6031                 }
6032             }
6033
6034           BFD_ASSERT (map->count > 0);
6035
6036           /* Add the current segment to the list of built segments.  */
6037           *pointer_to_map = map;
6038           pointer_to_map = &map->next;
6039
6040           if (isec < section_count)
6041             {
6042               /* We still have not allocated all of the sections to
6043                  segments.  Create a new segment here, initialise it
6044                  and carry on looping.  */
6045               amt = sizeof (struct elf_segment_map);
6046               amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
6047               map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6048               if (map == NULL)
6049                 {
6050                   free (sections);
6051                   return FALSE;
6052                 }
6053
6054               /* Initialise the fields of the segment map.  Set the physical
6055                  physical address to the LMA of the first section that has
6056                  not yet been assigned.  */
6057               map->next = NULL;
6058               map->p_type = segment->p_type;
6059               map->p_flags = segment->p_flags;
6060               map->p_flags_valid = 1;
6061               map->p_paddr = suggested_lma;
6062               map->p_paddr_valid = p_paddr_valid;
6063               map->includes_filehdr = 0;
6064               map->includes_phdrs = 0;
6065             }
6066         }
6067       while (isec < section_count);
6068
6069       free (sections);
6070     }
6071
6072   elf_tdata (obfd)->segment_map = map_first;
6073
6074   /* If we had to estimate the number of program headers that were
6075      going to be needed, then check our estimate now and adjust
6076      the offset if necessary.  */
6077   if (phdr_adjust_seg != NULL)
6078     {
6079       unsigned int count;
6080
6081       for (count = 0, map = map_first; map != NULL; map = map->next)
6082         count++;
6083
6084       if (count > phdr_adjust_num)
6085         phdr_adjust_seg->p_paddr
6086           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
6087     }
6088
6089 #undef SEGMENT_END
6090 #undef SECTION_SIZE
6091 #undef IS_CONTAINED_BY_VMA
6092 #undef IS_CONTAINED_BY_LMA
6093 #undef IS_NOTE
6094 #undef IS_COREFILE_NOTE
6095 #undef IS_SOLARIS_PT_INTERP
6096 #undef IS_SECTION_IN_INPUT_SEGMENT
6097 #undef INCLUDE_SECTION_IN_SEGMENT
6098 #undef SEGMENT_AFTER_SEGMENT
6099 #undef SEGMENT_OVERLAPS
6100   return TRUE;
6101 }
6102
6103 /* Copy ELF program header information.  */
6104
6105 static bfd_boolean
6106 copy_elf_program_header (bfd *ibfd, bfd *obfd)
6107 {
6108   Elf_Internal_Ehdr *iehdr;
6109   struct elf_segment_map *map;
6110   struct elf_segment_map *map_first;
6111   struct elf_segment_map **pointer_to_map;
6112   Elf_Internal_Phdr *segment;
6113   unsigned int i;
6114   unsigned int num_segments;
6115   bfd_boolean phdr_included = FALSE;
6116   bfd_boolean p_paddr_valid;
6117
6118   iehdr = elf_elfheader (ibfd);
6119
6120   map_first = NULL;
6121   pointer_to_map = &map_first;
6122
6123   /* If all the segment p_paddr fields are zero, don't set
6124      map->p_paddr_valid.  */
6125   p_paddr_valid = FALSE;
6126   num_segments = elf_elfheader (ibfd)->e_phnum;
6127   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6128        i < num_segments;
6129        i++, segment++)
6130     if (segment->p_paddr != 0)
6131       {
6132         p_paddr_valid = TRUE;
6133         break;
6134       }
6135
6136   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6137        i < num_segments;
6138        i++, segment++)
6139     {
6140       asection *section;
6141       unsigned int section_count;
6142       bfd_size_type amt;
6143       Elf_Internal_Shdr *this_hdr;
6144       asection *first_section = NULL;
6145       asection *lowest_section;
6146
6147       /* Compute how many sections are in this segment.  */
6148       for (section = ibfd->sections, section_count = 0;
6149            section != NULL;
6150            section = section->next)
6151         {
6152           this_hdr = &(elf_section_data(section)->this_hdr);
6153           if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6154             {
6155               if (first_section == NULL)
6156                 first_section = section;
6157               section_count++;
6158             }
6159         }
6160
6161       /* Allocate a segment map big enough to contain
6162          all of the sections we have selected.  */
6163       amt = sizeof (struct elf_segment_map);
6164       if (section_count != 0)
6165         amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
6166       map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6167       if (map == NULL)
6168         return FALSE;
6169
6170       /* Initialize the fields of the output segment map with the
6171          input segment.  */
6172       map->next = NULL;
6173       map->p_type = segment->p_type;
6174       map->p_flags = segment->p_flags;
6175       map->p_flags_valid = 1;
6176       map->p_paddr = segment->p_paddr;
6177       map->p_paddr_valid = p_paddr_valid;
6178       map->p_align = segment->p_align;
6179       map->p_align_valid = 1;
6180       map->p_vaddr_offset = 0;
6181
6182       if (map->p_type == PT_GNU_RELRO
6183           || map->p_type == PT_GNU_STACK)
6184         {
6185           /* The PT_GNU_RELRO segment may contain the first a few
6186              bytes in the .got.plt section even if the whole .got.plt
6187              section isn't in the PT_GNU_RELRO segment.  We won't
6188              change the size of the PT_GNU_RELRO segment.
6189              Similarly, PT_GNU_STACK size is significant on uclinux
6190              systems.    */
6191           map->p_size = segment->p_memsz;
6192           map->p_size_valid = 1;
6193         }
6194
6195       /* Determine if this segment contains the ELF file header
6196          and if it contains the program headers themselves.  */
6197       map->includes_filehdr = (segment->p_offset == 0
6198                                && segment->p_filesz >= iehdr->e_ehsize);
6199
6200       map->includes_phdrs = 0;
6201       if (! phdr_included || segment->p_type != PT_LOAD)
6202         {
6203           map->includes_phdrs =
6204             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6205              && (segment->p_offset + segment->p_filesz
6206                  >= ((bfd_vma) iehdr->e_phoff
6207                      + iehdr->e_phnum * iehdr->e_phentsize)));
6208
6209           if (segment->p_type == PT_LOAD && map->includes_phdrs)
6210             phdr_included = TRUE;
6211         }
6212
6213       lowest_section = first_section;
6214       if (section_count != 0)
6215         {
6216           unsigned int isec = 0;
6217
6218           for (section = first_section;
6219                section != NULL;
6220                section = section->next)
6221             {
6222               this_hdr = &(elf_section_data(section)->this_hdr);
6223               if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6224                 {
6225                   map->sections[isec++] = section->output_section;
6226                   if (section->lma < lowest_section->lma)
6227                     lowest_section = section;
6228                   if ((section->flags & SEC_ALLOC) != 0)
6229                     {
6230                       bfd_vma seg_off;
6231
6232                       /* Section lmas are set up from PT_LOAD header
6233                          p_paddr in _bfd_elf_make_section_from_shdr.
6234                          If this header has a p_paddr that disagrees
6235                          with the section lma, flag the p_paddr as
6236                          invalid.  */
6237                       if ((section->flags & SEC_LOAD) != 0)
6238                         seg_off = this_hdr->sh_offset - segment->p_offset;
6239                       else
6240                         seg_off = this_hdr->sh_addr - segment->p_vaddr;
6241                       if (section->lma - segment->p_paddr != seg_off)
6242                         map->p_paddr_valid = FALSE;
6243                     }
6244                   if (isec == section_count)
6245                     break;
6246                 }
6247             }
6248         }
6249
6250       if (map->includes_filehdr && lowest_section != NULL)
6251         /* We need to keep the space used by the headers fixed.  */
6252         map->header_size = lowest_section->vma - segment->p_vaddr;
6253
6254       if (!map->includes_phdrs
6255           && !map->includes_filehdr
6256           && map->p_paddr_valid)
6257         /* There is some other padding before the first section.  */
6258         map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
6259                                - segment->p_paddr);
6260
6261       map->count = section_count;
6262       *pointer_to_map = map;
6263       pointer_to_map = &map->next;
6264     }
6265
6266   elf_tdata (obfd)->segment_map = map_first;
6267   return TRUE;
6268 }
6269
6270 /* Copy private BFD data.  This copies or rewrites ELF program header
6271    information.  */
6272
6273 static bfd_boolean
6274 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6275 {
6276   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6277       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6278     return TRUE;
6279
6280   if (elf_tdata (ibfd)->phdr == NULL)
6281     return TRUE;
6282
6283   if (ibfd->xvec == obfd->xvec)
6284     {
6285       /* Check to see if any sections in the input BFD
6286          covered by ELF program header have changed.  */
6287       Elf_Internal_Phdr *segment;
6288       asection *section, *osec;
6289       unsigned int i, num_segments;
6290       Elf_Internal_Shdr *this_hdr;
6291       const struct elf_backend_data *bed;
6292
6293       bed = get_elf_backend_data (ibfd);
6294
6295       /* Regenerate the segment map if p_paddr is set to 0.  */
6296       if (bed->want_p_paddr_set_to_zero)
6297         goto rewrite;
6298
6299       /* Initialize the segment mark field.  */
6300       for (section = obfd->sections; section != NULL;
6301            section = section->next)
6302         section->segment_mark = FALSE;
6303
6304       num_segments = elf_elfheader (ibfd)->e_phnum;
6305       for (i = 0, segment = elf_tdata (ibfd)->phdr;
6306            i < num_segments;
6307            i++, segment++)
6308         {
6309           /* PR binutils/3535.  The Solaris linker always sets the p_paddr
6310              and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6311              which severly confuses things, so always regenerate the segment
6312              map in this case.  */
6313           if (segment->p_paddr == 0
6314               && segment->p_memsz == 0
6315               && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
6316             goto rewrite;
6317
6318           for (section = ibfd->sections;
6319                section != NULL; section = section->next)
6320             {
6321               /* We mark the output section so that we know it comes
6322                  from the input BFD.  */
6323               osec = section->output_section;
6324               if (osec)
6325                 osec->segment_mark = TRUE;
6326
6327               /* Check if this section is covered by the segment.  */
6328               this_hdr = &(elf_section_data(section)->this_hdr);
6329               if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6330                 {
6331                   /* FIXME: Check if its output section is changed or
6332                      removed.  What else do we need to check?  */
6333                   if (osec == NULL
6334                       || section->flags != osec->flags
6335                       || section->lma != osec->lma
6336                       || section->vma != osec->vma
6337                       || section->size != osec->size
6338                       || section->rawsize != osec->rawsize
6339                       || section->alignment_power != osec->alignment_power)
6340                     goto rewrite;
6341                 }
6342             }
6343         }
6344
6345       /* Check to see if any output section do not come from the
6346          input BFD.  */
6347       for (section = obfd->sections; section != NULL;
6348            section = section->next)
6349         {
6350           if (section->segment_mark == FALSE)
6351             goto rewrite;
6352           else
6353             section->segment_mark = FALSE;
6354         }
6355
6356       return copy_elf_program_header (ibfd, obfd);
6357     }
6358
6359 rewrite:
6360   if (ibfd->xvec == obfd->xvec)
6361     {
6362       /* When rewriting program header, set the output maxpagesize to
6363          the maximum alignment of input PT_LOAD segments.  */
6364       Elf_Internal_Phdr *segment;
6365       unsigned int i;
6366       unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
6367       bfd_vma maxpagesize = 0;
6368
6369       for (i = 0, segment = elf_tdata (ibfd)->phdr;
6370            i < num_segments;
6371            i++, segment++)
6372         if (segment->p_type == PT_LOAD
6373             && maxpagesize < segment->p_align)
6374           maxpagesize = segment->p_align;
6375
6376       if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
6377         bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
6378     }
6379
6380   return rewrite_elf_program_header (ibfd, obfd);
6381 }
6382
6383 /* Initialize private output section information from input section.  */
6384
6385 bfd_boolean
6386 _bfd_elf_init_private_section_data (bfd *ibfd,
6387                                     asection *isec,
6388                                     bfd *obfd,
6389                                     asection *osec,
6390                                     struct bfd_link_info *link_info)
6391
6392 {
6393   Elf_Internal_Shdr *ihdr, *ohdr;
6394   bfd_boolean final_link = link_info != NULL && !link_info->relocatable;
6395
6396   if (ibfd->xvec->flavour != bfd_target_elf_flavour
6397       || obfd->xvec->flavour != bfd_target_elf_flavour)
6398     return TRUE;
6399
6400   BFD_ASSERT (elf_section_data (osec) != NULL);
6401
6402   /* For objcopy and relocatable link, don't copy the output ELF
6403      section type from input if the output BFD section flags have been
6404      set to something different.  For a final link allow some flags
6405      that the linker clears to differ.  */
6406   if (elf_section_type (osec) == SHT_NULL
6407       && (osec->flags == isec->flags
6408           || (final_link
6409               && ((osec->flags ^ isec->flags)
6410                   & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
6411     elf_section_type (osec) = elf_section_type (isec);
6412
6413   /* FIXME: Is this correct for all OS/PROC specific flags?  */
6414   elf_section_flags (osec) |= (elf_section_flags (isec)
6415                                & (SHF_MASKOS | SHF_MASKPROC));
6416
6417   /* Set things up for objcopy and relocatable link.  The output
6418      SHT_GROUP section will have its elf_next_in_group pointing back
6419      to the input group members.  Ignore linker created group section.
6420      See elfNN_ia64_object_p in elfxx-ia64.c.  */
6421   if (!final_link)
6422     {
6423       if (elf_sec_group (isec) == NULL
6424           || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6425         {
6426           if (elf_section_flags (isec) & SHF_GROUP)
6427             elf_section_flags (osec) |= SHF_GROUP;
6428           elf_next_in_group (osec) = elf_next_in_group (isec);
6429           elf_section_data (osec)->group = elf_section_data (isec)->group;
6430         }
6431     }
6432
6433   ihdr = &elf_section_data (isec)->this_hdr;
6434
6435   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6436      don't use the output section of the linked-to section since it
6437      may be NULL at this point.  */
6438   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6439     {
6440       ohdr = &elf_section_data (osec)->this_hdr;
6441       ohdr->sh_flags |= SHF_LINK_ORDER;
6442       elf_linked_to_section (osec) = elf_linked_to_section (isec);
6443     }
6444
6445   osec->use_rela_p = isec->use_rela_p;
6446
6447   return TRUE;
6448 }
6449
6450 /* Copy private section information.  This copies over the entsize
6451    field, and sometimes the info field.  */
6452
6453 bfd_boolean
6454 _bfd_elf_copy_private_section_data (bfd *ibfd,
6455                                     asection *isec,
6456                                     bfd *obfd,
6457                                     asection *osec)
6458 {
6459   Elf_Internal_Shdr *ihdr, *ohdr;
6460
6461   if (ibfd->xvec->flavour != bfd_target_elf_flavour
6462       || obfd->xvec->flavour != bfd_target_elf_flavour)
6463     return TRUE;
6464
6465   ihdr = &elf_section_data (isec)->this_hdr;
6466   ohdr = &elf_section_data (osec)->this_hdr;
6467
6468   ohdr->sh_entsize = ihdr->sh_entsize;
6469
6470   if (ihdr->sh_type == SHT_SYMTAB
6471       || ihdr->sh_type == SHT_DYNSYM
6472       || ihdr->sh_type == SHT_GNU_verneed
6473       || ihdr->sh_type == SHT_GNU_verdef)
6474     ohdr->sh_info = ihdr->sh_info;
6475
6476   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6477                                              NULL);
6478 }
6479
6480 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6481    necessary if we are removing either the SHT_GROUP section or any of
6482    the group member sections.  DISCARDED is the value that a section's
6483    output_section has if the section will be discarded, NULL when this
6484    function is called from objcopy, bfd_abs_section_ptr when called
6485    from the linker.  */
6486
6487 bfd_boolean
6488 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
6489 {
6490   asection *isec;
6491
6492   for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6493     if (elf_section_type (isec) == SHT_GROUP)
6494       {
6495         asection *first = elf_next_in_group (isec);
6496         asection *s = first;
6497         bfd_size_type removed = 0;
6498
6499         while (s != NULL)
6500           {
6501             /* If this member section is being output but the
6502                SHT_GROUP section is not, then clear the group info
6503                set up by _bfd_elf_copy_private_section_data.  */
6504             if (s->output_section != discarded
6505                 && isec->output_section == discarded)
6506               {
6507                 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6508                 elf_group_name (s->output_section) = NULL;
6509               }
6510             /* Conversely, if the member section is not being output
6511                but the SHT_GROUP section is, then adjust its size.  */
6512             else if (s->output_section == discarded
6513                      && isec->output_section != discarded)
6514               removed += 4;
6515             s = elf_next_in_group (s);
6516             if (s == first)
6517               break;
6518           }
6519         if (removed != 0)
6520           {
6521             if (discarded != NULL)
6522               {
6523                 /* If we've been called for ld -r, then we need to
6524                    adjust the input section size.  This function may
6525                    be called multiple times, so save the original
6526                    size.  */
6527                 if (isec->rawsize == 0)
6528                   isec->rawsize = isec->size;
6529                 isec->size = isec->rawsize - removed;
6530               }
6531             else
6532               {
6533                 /* Adjust the output section size when called from
6534                    objcopy. */
6535                 isec->output_section->size -= removed;
6536               }
6537           }
6538       }
6539
6540   return TRUE;
6541 }
6542
6543 /* Copy private header information.  */
6544
6545 bfd_boolean
6546 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6547 {
6548   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6549       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6550     return TRUE;
6551
6552   /* Copy over private BFD data if it has not already been copied.
6553      This must be done here, rather than in the copy_private_bfd_data
6554      entry point, because the latter is called after the section
6555      contents have been set, which means that the program headers have
6556      already been worked out.  */
6557   if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6558     {
6559       if (! copy_private_bfd_data (ibfd, obfd))
6560         return FALSE;
6561     }
6562
6563   return _bfd_elf_fixup_group_sections (ibfd, NULL);
6564 }
6565
6566 /* Copy private symbol information.  If this symbol is in a section
6567    which we did not map into a BFD section, try to map the section
6568    index correctly.  We use special macro definitions for the mapped
6569    section indices; these definitions are interpreted by the
6570    swap_out_syms function.  */
6571
6572 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6573 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6574 #define MAP_STRTAB    (SHN_HIOS + 3)
6575 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
6576 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6577
6578 bfd_boolean
6579 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6580                                    asymbol *isymarg,
6581                                    bfd *obfd,
6582                                    asymbol *osymarg)
6583 {
6584   elf_symbol_type *isym, *osym;
6585
6586   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6587       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6588     return TRUE;
6589
6590   isym = elf_symbol_from (ibfd, isymarg);
6591   osym = elf_symbol_from (obfd, osymarg);
6592
6593   if (isym != NULL
6594       && isym->internal_elf_sym.st_shndx != 0
6595       && osym != NULL
6596       && bfd_is_abs_section (isym->symbol.section))
6597     {
6598       unsigned int shndx;
6599
6600       shndx = isym->internal_elf_sym.st_shndx;
6601       if (shndx == elf_onesymtab (ibfd))
6602         shndx = MAP_ONESYMTAB;
6603       else if (shndx == elf_dynsymtab (ibfd))
6604         shndx = MAP_DYNSYMTAB;
6605       else if (shndx == elf_tdata (ibfd)->strtab_section)
6606         shndx = MAP_STRTAB;
6607       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6608         shndx = MAP_SHSTRTAB;
6609       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6610         shndx = MAP_SYM_SHNDX;
6611       osym->internal_elf_sym.st_shndx = shndx;
6612     }
6613
6614   return TRUE;
6615 }
6616
6617 /* Swap out the symbols.  */
6618
6619 static bfd_boolean
6620 swap_out_syms (bfd *abfd,
6621                struct bfd_strtab_hash **sttp,
6622                int relocatable_p)
6623 {
6624   const struct elf_backend_data *bed;
6625   int symcount;
6626   asymbol **syms;
6627   struct bfd_strtab_hash *stt;
6628   Elf_Internal_Shdr *symtab_hdr;
6629   Elf_Internal_Shdr *symtab_shndx_hdr;
6630   Elf_Internal_Shdr *symstrtab_hdr;
6631   bfd_byte *outbound_syms;
6632   bfd_byte *outbound_shndx;
6633   int idx;
6634   bfd_size_type amt;
6635   bfd_boolean name_local_sections;
6636
6637   if (!elf_map_symbols (abfd))
6638     return FALSE;
6639
6640   /* Dump out the symtabs.  */
6641   stt = _bfd_elf_stringtab_init ();
6642   if (stt == NULL)
6643     return FALSE;
6644
6645   bed = get_elf_backend_data (abfd);
6646   symcount = bfd_get_symcount (abfd);
6647   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6648   symtab_hdr->sh_type = SHT_SYMTAB;
6649   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6650   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6651   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6652   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
6653
6654   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6655   symstrtab_hdr->sh_type = SHT_STRTAB;
6656
6657   outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
6658                                            bed->s->sizeof_sym);
6659   if (outbound_syms == NULL)
6660     {
6661       _bfd_stringtab_free (stt);
6662       return FALSE;
6663     }
6664   symtab_hdr->contents = outbound_syms;
6665
6666   outbound_shndx = NULL;
6667   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6668   if (symtab_shndx_hdr->sh_name != 0)
6669     {
6670       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6671       outbound_shndx =  (bfd_byte *)
6672           bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
6673       if (outbound_shndx == NULL)
6674         {
6675           _bfd_stringtab_free (stt);
6676           return FALSE;
6677         }
6678
6679       symtab_shndx_hdr->contents = outbound_shndx;
6680       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6681       symtab_shndx_hdr->sh_size = amt;
6682       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6683       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6684     }
6685
6686   /* Now generate the data (for "contents").  */
6687   {
6688     /* Fill in zeroth symbol and swap it out.  */
6689     Elf_Internal_Sym sym;
6690     sym.st_name = 0;
6691     sym.st_value = 0;
6692     sym.st_size = 0;
6693     sym.st_info = 0;
6694     sym.st_other = 0;
6695     sym.st_shndx = SHN_UNDEF;
6696     sym.st_target_internal = 0;
6697     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6698     outbound_syms += bed->s->sizeof_sym;
6699     if (outbound_shndx != NULL)
6700       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6701   }
6702
6703   name_local_sections
6704     = (bed->elf_backend_name_local_section_symbols
6705        && bed->elf_backend_name_local_section_symbols (abfd));
6706
6707   syms = bfd_get_outsymbols (abfd);
6708   for (idx = 0; idx < symcount; idx++)
6709     {
6710       Elf_Internal_Sym sym;
6711       bfd_vma value = syms[idx]->value;
6712       elf_symbol_type *type_ptr;
6713       flagword flags = syms[idx]->flags;
6714       int type;
6715
6716       if (!name_local_sections
6717           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6718         {
6719           /* Local section symbols have no name.  */
6720           sym.st_name = 0;
6721         }
6722       else
6723         {
6724           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6725                                                             syms[idx]->name,
6726                                                             TRUE, FALSE);
6727           if (sym.st_name == (unsigned long) -1)
6728             {
6729               _bfd_stringtab_free (stt);
6730               return FALSE;
6731             }
6732         }
6733
6734       type_ptr = elf_symbol_from (abfd, syms[idx]);
6735
6736       if ((flags & BSF_SECTION_SYM) == 0
6737           && bfd_is_com_section (syms[idx]->section))
6738         {
6739           /* ELF common symbols put the alignment into the `value' field,
6740              and the size into the `size' field.  This is backwards from
6741              how BFD handles it, so reverse it here.  */
6742           sym.st_size = value;
6743           if (type_ptr == NULL
6744               || type_ptr->internal_elf_sym.st_value == 0)
6745             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6746           else
6747             sym.st_value = type_ptr->internal_elf_sym.st_value;
6748           sym.st_shndx = _bfd_elf_section_from_bfd_section
6749             (abfd, syms[idx]->section);
6750         }
6751       else
6752         {
6753           asection *sec = syms[idx]->section;
6754           unsigned int shndx;
6755
6756           if (sec->output_section)
6757             {
6758               value += sec->output_offset;
6759               sec = sec->output_section;
6760             }
6761
6762           /* Don't add in the section vma for relocatable output.  */
6763           if (! relocatable_p)
6764             value += sec->vma;
6765           sym.st_value = value;
6766           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6767
6768           if (bfd_is_abs_section (sec)
6769               && type_ptr != NULL
6770               && type_ptr->internal_elf_sym.st_shndx != 0)
6771             {
6772               /* This symbol is in a real ELF section which we did
6773                  not create as a BFD section.  Undo the mapping done
6774                  by copy_private_symbol_data.  */
6775               shndx = type_ptr->internal_elf_sym.st_shndx;
6776               switch (shndx)
6777                 {
6778                 case MAP_ONESYMTAB:
6779                   shndx = elf_onesymtab (abfd);
6780                   break;
6781                 case MAP_DYNSYMTAB:
6782                   shndx = elf_dynsymtab (abfd);
6783                   break;
6784                 case MAP_STRTAB:
6785                   shndx = elf_tdata (abfd)->strtab_section;
6786                   break;
6787                 case MAP_SHSTRTAB:
6788                   shndx = elf_tdata (abfd)->shstrtab_section;
6789                   break;
6790                 case MAP_SYM_SHNDX:
6791                   shndx = elf_tdata (abfd)->symtab_shndx_section;
6792                   break;
6793                 default:
6794                   shndx = SHN_ABS;
6795                   break;
6796                 }
6797             }
6798           else
6799             {
6800               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6801
6802               if (shndx == SHN_BAD)
6803                 {
6804                   asection *sec2;
6805
6806                   /* Writing this would be a hell of a lot easier if
6807                      we had some decent documentation on bfd, and
6808                      knew what to expect of the library, and what to
6809                      demand of applications.  For example, it
6810                      appears that `objcopy' might not set the
6811                      section of a symbol to be a section that is
6812                      actually in the output file.  */
6813                   sec2 = bfd_get_section_by_name (abfd, sec->name);
6814                   if (sec2 == NULL)
6815                     {
6816                       _bfd_error_handler (_("\
6817 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6818                                           syms[idx]->name ? syms[idx]->name : "<Local sym>",
6819                                           sec->name);
6820                       bfd_set_error (bfd_error_invalid_operation);
6821                       _bfd_stringtab_free (stt);
6822                       return FALSE;
6823                     }
6824
6825                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6826                   BFD_ASSERT (shndx != SHN_BAD);
6827                 }
6828             }
6829
6830           sym.st_shndx = shndx;
6831         }
6832
6833       if ((flags & BSF_THREAD_LOCAL) != 0)
6834         type = STT_TLS;
6835       else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
6836         type = STT_GNU_IFUNC;
6837       else if ((flags & BSF_FUNCTION) != 0)
6838         type = STT_FUNC;
6839       else if ((flags & BSF_OBJECT) != 0)
6840         type = STT_OBJECT;
6841       else if ((flags & BSF_RELC) != 0)
6842         type = STT_RELC;
6843       else if ((flags & BSF_SRELC) != 0)
6844         type = STT_SRELC;
6845       else
6846         type = STT_NOTYPE;
6847
6848       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6849         type = STT_TLS;
6850
6851       /* Processor-specific types.  */
6852       if (type_ptr != NULL
6853           && bed->elf_backend_get_symbol_type)
6854         type = ((*bed->elf_backend_get_symbol_type)
6855                 (&type_ptr->internal_elf_sym, type));
6856
6857       if (flags & BSF_SECTION_SYM)
6858         {
6859           if (flags & BSF_GLOBAL)
6860             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6861           else
6862             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6863         }
6864       else if (bfd_is_com_section (syms[idx]->section))
6865         {
6866 #ifdef USE_STT_COMMON
6867           if (type == STT_OBJECT)
6868             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6869           else
6870 #endif
6871             sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6872         }
6873       else if (bfd_is_und_section (syms[idx]->section))
6874         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6875                                     ? STB_WEAK
6876                                     : STB_GLOBAL),
6877                                    type);
6878       else if (flags & BSF_FILE)
6879         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6880       else
6881         {
6882           int bind = STB_LOCAL;
6883
6884           if (flags & BSF_LOCAL)
6885             bind = STB_LOCAL;
6886           else if (flags & BSF_GNU_UNIQUE)
6887             bind = STB_GNU_UNIQUE;
6888           else if (flags & BSF_WEAK)
6889             bind = STB_WEAK;
6890           else if (flags & BSF_GLOBAL)
6891             bind = STB_GLOBAL;
6892
6893           sym.st_info = ELF_ST_INFO (bind, type);
6894         }
6895
6896       if (type_ptr != NULL)
6897         {
6898           sym.st_other = type_ptr->internal_elf_sym.st_other;
6899           sym.st_target_internal
6900             = type_ptr->internal_elf_sym.st_target_internal;
6901         }
6902       else
6903         {
6904           sym.st_other = 0;
6905           sym.st_target_internal = 0;
6906         }
6907
6908       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6909       outbound_syms += bed->s->sizeof_sym;
6910       if (outbound_shndx != NULL)
6911         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6912     }
6913
6914   *sttp = stt;
6915   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6916   symstrtab_hdr->sh_type = SHT_STRTAB;
6917
6918   symstrtab_hdr->sh_flags = 0;
6919   symstrtab_hdr->sh_addr = 0;
6920   symstrtab_hdr->sh_entsize = 0;
6921   symstrtab_hdr->sh_link = 0;
6922   symstrtab_hdr->sh_info = 0;
6923   symstrtab_hdr->sh_addralign = 1;
6924
6925   return TRUE;
6926 }
6927
6928 /* Return the number of bytes required to hold the symtab vector.
6929
6930    Note that we base it on the count plus 1, since we will null terminate
6931    the vector allocated based on this size.  However, the ELF symbol table
6932    always has a dummy entry as symbol #0, so it ends up even.  */
6933
6934 long
6935 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6936 {
6937   long symcount;
6938   long symtab_size;
6939   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6940
6941   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6942   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6943   if (symcount > 0)
6944     symtab_size -= sizeof (asymbol *);
6945
6946   return symtab_size;
6947 }
6948
6949 long
6950 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6951 {
6952   long symcount;
6953   long symtab_size;
6954   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6955
6956   if (elf_dynsymtab (abfd) == 0)
6957     {
6958       bfd_set_error (bfd_error_invalid_operation);
6959       return -1;
6960     }
6961
6962   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6963   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6964   if (symcount > 0)
6965     symtab_size -= sizeof (asymbol *);
6966
6967   return symtab_size;
6968 }
6969
6970 long
6971 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6972                                 sec_ptr asect)
6973 {
6974   return (asect->reloc_count + 1) * sizeof (arelent *);
6975 }
6976
6977 /* Canonicalize the relocs.  */
6978
6979 long
6980 _bfd_elf_canonicalize_reloc (bfd *abfd,
6981                              sec_ptr section,
6982                              arelent **relptr,
6983                              asymbol **symbols)
6984 {
6985   arelent *tblptr;
6986   unsigned int i;
6987   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6988
6989   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6990     return -1;
6991
6992   tblptr = section->relocation;
6993   for (i = 0; i < section->reloc_count; i++)
6994     *relptr++ = tblptr++;
6995
6996   *relptr = NULL;
6997
6998   return section->reloc_count;
6999 }
7000
7001 long
7002 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
7003 {
7004   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7005   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
7006
7007   if (symcount >= 0)
7008     bfd_get_symcount (abfd) = symcount;
7009   return symcount;
7010 }
7011
7012 long
7013 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
7014                                       asymbol **allocation)
7015 {
7016   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7017   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
7018
7019   if (symcount >= 0)
7020     bfd_get_dynamic_symcount (abfd) = symcount;
7021   return symcount;
7022 }
7023
7024 /* Return the size required for the dynamic reloc entries.  Any loadable
7025    section that was actually installed in the BFD, and has type SHT_REL
7026    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
7027    dynamic reloc section.  */
7028
7029 long
7030 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
7031 {
7032   long ret;
7033   asection *s;
7034
7035   if (elf_dynsymtab (abfd) == 0)
7036     {
7037       bfd_set_error (bfd_error_invalid_operation);
7038       return -1;
7039     }
7040
7041   ret = sizeof (arelent *);
7042   for (s = abfd->sections; s != NULL; s = s->next)
7043     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
7044         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
7045             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
7046       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
7047               * sizeof (arelent *));
7048
7049   return ret;
7050 }
7051
7052 /* Canonicalize the dynamic relocation entries.  Note that we return the
7053    dynamic relocations as a single block, although they are actually
7054    associated with particular sections; the interface, which was
7055    designed for SunOS style shared libraries, expects that there is only
7056    one set of dynamic relocs.  Any loadable section that was actually
7057    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
7058    dynamic symbol table, is considered to be a dynamic reloc section.  */
7059
7060 long
7061 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
7062                                      arelent **storage,
7063                                      asymbol **syms)
7064 {
7065   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
7066   asection *s;
7067   long ret;
7068
7069   if (elf_dynsymtab (abfd) == 0)
7070     {
7071       bfd_set_error (bfd_error_invalid_operation);
7072       return -1;
7073     }
7074
7075   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
7076   ret = 0;
7077   for (s = abfd->sections; s != NULL; s = s->next)
7078     {
7079       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
7080           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
7081               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
7082         {
7083           arelent *p;
7084           long count, i;
7085
7086           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
7087             return -1;
7088           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
7089           p = s->relocation;
7090           for (i = 0; i < count; i++)
7091             *storage++ = p++;
7092           ret += count;
7093         }
7094     }
7095
7096   *storage = NULL;
7097
7098   return ret;
7099 }
7100 \f
7101 /* Read in the version information.  */
7102
7103 bfd_boolean
7104 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
7105 {
7106   bfd_byte *contents = NULL;
7107   unsigned int freeidx = 0;
7108
7109   if (elf_dynverref (abfd) != 0)
7110     {
7111       Elf_Internal_Shdr *hdr;
7112       Elf_External_Verneed *everneed;
7113       Elf_Internal_Verneed *iverneed;
7114       unsigned int i;
7115       bfd_byte *contents_end;
7116
7117       hdr = &elf_tdata (abfd)->dynverref_hdr;
7118
7119       elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
7120           bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
7121       if (elf_tdata (abfd)->verref == NULL)
7122         goto error_return;
7123
7124       elf_tdata (abfd)->cverrefs = hdr->sh_info;
7125
7126       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
7127       if (contents == NULL)
7128         {
7129 error_return_verref:
7130           elf_tdata (abfd)->verref = NULL;
7131           elf_tdata (abfd)->cverrefs = 0;
7132           goto error_return;
7133         }
7134       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7135           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
7136         goto error_return_verref;
7137
7138       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
7139         goto error_return_verref;
7140
7141       BFD_ASSERT (sizeof (Elf_External_Verneed)
7142                   == sizeof (Elf_External_Vernaux));
7143       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
7144       everneed = (Elf_External_Verneed *) contents;
7145       iverneed = elf_tdata (abfd)->verref;
7146       for (i = 0; i < hdr->sh_info; i++, iverneed++)
7147         {
7148           Elf_External_Vernaux *evernaux;
7149           Elf_Internal_Vernaux *ivernaux;
7150           unsigned int j;
7151
7152           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
7153
7154           iverneed->vn_bfd = abfd;
7155
7156           iverneed->vn_filename =
7157             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7158                                              iverneed->vn_file);
7159           if (iverneed->vn_filename == NULL)
7160             goto error_return_verref;
7161
7162           if (iverneed->vn_cnt == 0)
7163             iverneed->vn_auxptr = NULL;
7164           else
7165             {
7166               iverneed->vn_auxptr = (struct elf_internal_vernaux *)
7167                   bfd_alloc2 (abfd, iverneed->vn_cnt,
7168                               sizeof (Elf_Internal_Vernaux));
7169               if (iverneed->vn_auxptr == NULL)
7170                 goto error_return_verref;
7171             }
7172
7173           if (iverneed->vn_aux
7174               > (size_t) (contents_end - (bfd_byte *) everneed))
7175             goto error_return_verref;
7176
7177           evernaux = ((Elf_External_Vernaux *)
7178                       ((bfd_byte *) everneed + iverneed->vn_aux));
7179           ivernaux = iverneed->vn_auxptr;
7180           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
7181             {
7182               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
7183
7184               ivernaux->vna_nodename =
7185                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7186                                                  ivernaux->vna_name);
7187               if (ivernaux->vna_nodename == NULL)
7188                 goto error_return_verref;
7189
7190               if (j + 1 < iverneed->vn_cnt)
7191                 ivernaux->vna_nextptr = ivernaux + 1;
7192               else
7193                 ivernaux->vna_nextptr = NULL;
7194
7195               if (ivernaux->vna_next
7196                   > (size_t) (contents_end - (bfd_byte *) evernaux))
7197                 goto error_return_verref;
7198
7199               evernaux = ((Elf_External_Vernaux *)
7200                           ((bfd_byte *) evernaux + ivernaux->vna_next));
7201
7202               if (ivernaux->vna_other > freeidx)
7203                 freeidx = ivernaux->vna_other;
7204             }
7205
7206           if (i + 1 < hdr->sh_info)
7207             iverneed->vn_nextref = iverneed + 1;
7208           else
7209             iverneed->vn_nextref = NULL;
7210
7211           if (iverneed->vn_next
7212               > (size_t) (contents_end - (bfd_byte *) everneed))
7213             goto error_return_verref;
7214
7215           everneed = ((Elf_External_Verneed *)
7216                       ((bfd_byte *) everneed + iverneed->vn_next));
7217         }
7218
7219       free (contents);
7220       contents = NULL;
7221     }
7222
7223   if (elf_dynverdef (abfd) != 0)
7224     {
7225       Elf_Internal_Shdr *hdr;
7226       Elf_External_Verdef *everdef;
7227       Elf_Internal_Verdef *iverdef;
7228       Elf_Internal_Verdef *iverdefarr;
7229       Elf_Internal_Verdef iverdefmem;
7230       unsigned int i;
7231       unsigned int maxidx;
7232       bfd_byte *contents_end_def, *contents_end_aux;
7233
7234       hdr = &elf_tdata (abfd)->dynverdef_hdr;
7235
7236       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
7237       if (contents == NULL)
7238         goto error_return;
7239       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7240           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
7241         goto error_return;
7242
7243       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
7244         goto error_return;
7245
7246       BFD_ASSERT (sizeof (Elf_External_Verdef)
7247                   >= sizeof (Elf_External_Verdaux));
7248       contents_end_def = contents + hdr->sh_size
7249                          - sizeof (Elf_External_Verdef);
7250       contents_end_aux = contents + hdr->sh_size
7251                          - sizeof (Elf_External_Verdaux);
7252
7253       /* We know the number of entries in the section but not the maximum
7254          index.  Therefore we have to run through all entries and find
7255          the maximum.  */
7256       everdef = (Elf_External_Verdef *) contents;
7257       maxidx = 0;
7258       for (i = 0; i < hdr->sh_info; ++i)
7259         {
7260           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7261
7262           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
7263             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
7264
7265           if (iverdefmem.vd_next
7266               > (size_t) (contents_end_def - (bfd_byte *) everdef))
7267             goto error_return;
7268
7269           everdef = ((Elf_External_Verdef *)
7270                      ((bfd_byte *) everdef + iverdefmem.vd_next));
7271         }
7272
7273       if (default_imported_symver)
7274         {
7275           if (freeidx > maxidx)
7276             maxidx = ++freeidx;
7277           else
7278             freeidx = ++maxidx;
7279         }
7280       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7281           bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
7282       if (elf_tdata (abfd)->verdef == NULL)
7283         goto error_return;
7284
7285       elf_tdata (abfd)->cverdefs = maxidx;
7286
7287       everdef = (Elf_External_Verdef *) contents;
7288       iverdefarr = elf_tdata (abfd)->verdef;
7289       for (i = 0; i < hdr->sh_info; i++)
7290         {
7291           Elf_External_Verdaux *everdaux;
7292           Elf_Internal_Verdaux *iverdaux;
7293           unsigned int j;
7294
7295           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7296
7297           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
7298             {
7299 error_return_verdef:
7300               elf_tdata (abfd)->verdef = NULL;
7301               elf_tdata (abfd)->cverdefs = 0;
7302               goto error_return;
7303             }
7304
7305           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
7306           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
7307
7308           iverdef->vd_bfd = abfd;
7309
7310           if (iverdef->vd_cnt == 0)
7311             iverdef->vd_auxptr = NULL;
7312           else
7313             {
7314               iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7315                   bfd_alloc2 (abfd, iverdef->vd_cnt,
7316                               sizeof (Elf_Internal_Verdaux));
7317               if (iverdef->vd_auxptr == NULL)
7318                 goto error_return_verdef;
7319             }
7320
7321           if (iverdef->vd_aux
7322               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
7323             goto error_return_verdef;
7324
7325           everdaux = ((Elf_External_Verdaux *)
7326                       ((bfd_byte *) everdef + iverdef->vd_aux));
7327           iverdaux = iverdef->vd_auxptr;
7328           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
7329             {
7330               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
7331
7332               iverdaux->vda_nodename =
7333                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7334                                                  iverdaux->vda_name);
7335               if (iverdaux->vda_nodename == NULL)
7336                 goto error_return_verdef;
7337
7338               if (j + 1 < iverdef->vd_cnt)
7339                 iverdaux->vda_nextptr = iverdaux + 1;
7340               else
7341                 iverdaux->vda_nextptr = NULL;
7342
7343               if (iverdaux->vda_next
7344                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
7345                 goto error_return_verdef;
7346
7347               everdaux = ((Elf_External_Verdaux *)
7348                           ((bfd_byte *) everdaux + iverdaux->vda_next));
7349             }
7350
7351           if (iverdef->vd_cnt)
7352             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
7353
7354           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
7355             iverdef->vd_nextdef = iverdef + 1;
7356           else
7357             iverdef->vd_nextdef = NULL;
7358
7359           everdef = ((Elf_External_Verdef *)
7360                      ((bfd_byte *) everdef + iverdef->vd_next));
7361         }
7362
7363       free (contents);
7364       contents = NULL;
7365     }
7366   else if (default_imported_symver)
7367     {
7368       if (freeidx < 3)
7369         freeidx = 3;
7370       else
7371         freeidx++;
7372
7373       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7374           bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
7375       if (elf_tdata (abfd)->verdef == NULL)
7376         goto error_return;
7377
7378       elf_tdata (abfd)->cverdefs = freeidx;
7379     }
7380
7381   /* Create a default version based on the soname.  */
7382   if (default_imported_symver)
7383     {
7384       Elf_Internal_Verdef *iverdef;
7385       Elf_Internal_Verdaux *iverdaux;
7386
7387       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
7388
7389       iverdef->vd_version = VER_DEF_CURRENT;
7390       iverdef->vd_flags = 0;
7391       iverdef->vd_ndx = freeidx;
7392       iverdef->vd_cnt = 1;
7393
7394       iverdef->vd_bfd = abfd;
7395
7396       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
7397       if (iverdef->vd_nodename == NULL)
7398         goto error_return_verdef;
7399       iverdef->vd_nextdef = NULL;
7400       iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7401           bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
7402       if (iverdef->vd_auxptr == NULL)
7403         goto error_return_verdef;
7404
7405       iverdaux = iverdef->vd_auxptr;
7406       iverdaux->vda_nodename = iverdef->vd_nodename;
7407       iverdaux->vda_nextptr = NULL;
7408     }
7409
7410   return TRUE;
7411
7412  error_return:
7413   if (contents != NULL)
7414     free (contents);
7415   return FALSE;
7416 }
7417 \f
7418 asymbol *
7419 _bfd_elf_make_empty_symbol (bfd *abfd)
7420 {
7421   elf_symbol_type *newsym;
7422   bfd_size_type amt = sizeof (elf_symbol_type);
7423
7424   newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
7425   if (!newsym)
7426     return NULL;
7427   else
7428     {
7429       newsym->symbol.the_bfd = abfd;
7430       return &newsym->symbol;
7431     }
7432 }
7433
7434 void
7435 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7436                           asymbol *symbol,
7437                           symbol_info *ret)
7438 {
7439   bfd_symbol_info (symbol, ret);
7440 }
7441
7442 /* Return whether a symbol name implies a local symbol.  Most targets
7443    use this function for the is_local_label_name entry point, but some
7444    override it.  */
7445
7446 bfd_boolean
7447 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7448                               const char *name)
7449 {
7450   /* Normal local symbols start with ``.L''.  */
7451   if (name[0] == '.' && name[1] == 'L')
7452     return TRUE;
7453
7454   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7455      DWARF debugging symbols starting with ``..''.  */
7456   if (name[0] == '.' && name[1] == '.')
7457     return TRUE;
7458
7459   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7460      emitting DWARF debugging output.  I suspect this is actually a
7461      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7462      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7463      underscore to be emitted on some ELF targets).  For ease of use,
7464      we treat such symbols as local.  */
7465   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
7466     return TRUE;
7467
7468   return FALSE;
7469 }
7470
7471 alent *
7472 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7473                      asymbol *symbol ATTRIBUTE_UNUSED)
7474 {
7475   abort ();
7476   return NULL;
7477 }
7478
7479 bfd_boolean
7480 _bfd_elf_set_arch_mach (bfd *abfd,
7481                         enum bfd_architecture arch,
7482                         unsigned long machine)
7483 {
7484   /* If this isn't the right architecture for this backend, and this
7485      isn't the generic backend, fail.  */
7486   if (arch != get_elf_backend_data (abfd)->arch
7487       && arch != bfd_arch_unknown
7488       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
7489     return FALSE;
7490
7491   return bfd_default_set_arch_mach (abfd, arch, machine);
7492 }
7493
7494 /* Find the function to a particular section and offset,
7495    for error reporting.  */
7496
7497 static bfd_boolean
7498 elf_find_function (bfd *abfd,
7499                    asection *section,
7500                    asymbol **symbols,
7501                    bfd_vma offset,
7502                    const char **filename_ptr,
7503                    const char **functionname_ptr)
7504 {
7505   static asection *last_section;
7506   static asymbol *func;
7507   static const char *filename;
7508   static bfd_size_type func_size;
7509
7510   if (symbols == NULL)
7511     return FALSE;
7512
7513   if (last_section != section
7514       || func == NULL
7515       || offset < func->value
7516       || offset >= func->value + func_size)
7517     {
7518       asymbol *file;
7519       bfd_vma low_func;
7520       asymbol **p;
7521       /* ??? Given multiple file symbols, it is impossible to reliably
7522          choose the right file name for global symbols.  File symbols are
7523          local symbols, and thus all file symbols must sort before any
7524          global symbols.  The ELF spec may be interpreted to say that a
7525          file symbol must sort before other local symbols, but currently
7526          ld -r doesn't do this.  So, for ld -r output, it is possible to
7527          make a better choice of file name for local symbols by ignoring
7528          file symbols appearing after a given local symbol.  */
7529       enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7530       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7531
7532       filename = NULL;
7533       func = NULL;
7534       file = NULL;
7535       low_func = 0;
7536       state = nothing_seen;
7537       func_size = 0;
7538       last_section = section;
7539
7540       for (p = symbols; *p != NULL; p++)
7541         {
7542           asymbol *sym = *p;
7543           bfd_vma code_off;
7544           bfd_size_type size;
7545
7546           if ((sym->flags & BSF_FILE) != 0)
7547             {
7548               file = sym;
7549               if (state == symbol_seen)
7550                 state = file_after_symbol_seen;
7551               continue;
7552             }
7553
7554           size = bed->maybe_function_sym (sym, section, &code_off);
7555           if (size != 0
7556               && code_off <= offset
7557               && (code_off > low_func
7558                   || (code_off == low_func
7559                       && size > func_size)))
7560             {
7561               func = sym;
7562               func_size = size;
7563               low_func = code_off;
7564               filename = NULL;
7565               if (file != NULL
7566                   && ((sym->flags & BSF_LOCAL) != 0
7567                       || state != file_after_symbol_seen))
7568                 filename = bfd_asymbol_name (file);
7569             }
7570           if (state == nothing_seen)
7571             state = symbol_seen;
7572         }
7573     }
7574
7575   if (func == NULL)
7576     return FALSE;
7577
7578   if (filename_ptr)
7579     *filename_ptr = filename;
7580   if (functionname_ptr)
7581     *functionname_ptr = bfd_asymbol_name (func);
7582
7583   return TRUE;
7584 }
7585
7586 /* Find the nearest line to a particular section and offset,
7587    for error reporting.  */
7588
7589 bfd_boolean
7590 _bfd_elf_find_nearest_line (bfd *abfd,
7591                             asection *section,
7592                             asymbol **symbols,
7593                             bfd_vma offset,
7594                             const char **filename_ptr,
7595                             const char **functionname_ptr,
7596                             unsigned int *line_ptr)
7597 {
7598   return _bfd_elf_find_nearest_line_discriminator (abfd, section, symbols,
7599                                                    offset, filename_ptr,
7600                                                    functionname_ptr,
7601                                                    line_ptr,
7602                                                    NULL);
7603 }
7604
7605 bfd_boolean
7606 _bfd_elf_find_nearest_line_discriminator (bfd *abfd,
7607                                           asection *section,
7608                                           asymbol **symbols,
7609                                           bfd_vma offset,
7610                                           const char **filename_ptr,
7611                                           const char **functionname_ptr,
7612                                           unsigned int *line_ptr,
7613                                           unsigned int *discriminator_ptr)
7614 {
7615   bfd_boolean found;
7616
7617   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7618                                      filename_ptr, functionname_ptr,
7619                                      line_ptr))
7620     {
7621       if (!*functionname_ptr)
7622         elf_find_function (abfd, section, symbols, offset,
7623                            *filename_ptr ? NULL : filename_ptr,
7624                            functionname_ptr);
7625
7626       return TRUE;
7627     }
7628
7629   if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
7630                                      section, symbols, offset,
7631                                      filename_ptr, functionname_ptr,
7632                                      line_ptr, discriminator_ptr, 0,
7633                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7634     {
7635       if (!*functionname_ptr)
7636         elf_find_function (abfd, section, symbols, offset,
7637                            *filename_ptr ? NULL : filename_ptr,
7638                            functionname_ptr);
7639
7640       return TRUE;
7641     }
7642
7643   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7644                                              &found, filename_ptr,
7645                                              functionname_ptr, line_ptr,
7646                                              &elf_tdata (abfd)->line_info))
7647     return FALSE;
7648   if (found && (*functionname_ptr || *line_ptr))
7649     return TRUE;
7650
7651   if (symbols == NULL)
7652     return FALSE;
7653
7654   if (! elf_find_function (abfd, section, symbols, offset,
7655                            filename_ptr, functionname_ptr))
7656     return FALSE;
7657
7658   *line_ptr = 0;
7659   return TRUE;
7660 }
7661
7662 /* Find the line for a symbol.  */
7663
7664 bfd_boolean
7665 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7666                     const char **filename_ptr, unsigned int *line_ptr)
7667 {
7668   return _bfd_elf_find_line_discriminator (abfd, symbols, symbol,
7669                                            filename_ptr, line_ptr,
7670                                            NULL);
7671 }
7672
7673 bfd_boolean
7674 _bfd_elf_find_line_discriminator (bfd *abfd, asymbol **symbols, asymbol *symbol,
7675                                   const char **filename_ptr,
7676                                   unsigned int *line_ptr,
7677                                   unsigned int *discriminator_ptr)
7678 {
7679   return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7680                                 filename_ptr, line_ptr, discriminator_ptr, 0,
7681                                 &elf_tdata (abfd)->dwarf2_find_line_info);
7682 }
7683
7684 /* After a call to bfd_find_nearest_line, successive calls to
7685    bfd_find_inliner_info can be used to get source information about
7686    each level of function inlining that terminated at the address
7687    passed to bfd_find_nearest_line.  Currently this is only supported
7688    for DWARF2 with appropriate DWARF3 extensions. */
7689
7690 bfd_boolean
7691 _bfd_elf_find_inliner_info (bfd *abfd,
7692                             const char **filename_ptr,
7693                             const char **functionname_ptr,
7694                             unsigned int *line_ptr)
7695 {
7696   bfd_boolean found;
7697   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7698                                          functionname_ptr, line_ptr,
7699                                          & elf_tdata (abfd)->dwarf2_find_line_info);
7700   return found;
7701 }
7702
7703 int
7704 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7705 {
7706   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7707   int ret = bed->s->sizeof_ehdr;
7708
7709   if (!info->relocatable)
7710     {
7711       bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7712
7713       if (phdr_size == (bfd_size_type) -1)
7714         {
7715           struct elf_segment_map *m;
7716
7717           phdr_size = 0;
7718           for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7719             phdr_size += bed->s->sizeof_phdr;
7720
7721           if (phdr_size == 0)
7722             phdr_size = get_program_header_size (abfd, info);
7723         }
7724
7725       elf_tdata (abfd)->program_header_size = phdr_size;
7726       ret += phdr_size;
7727     }
7728
7729   return ret;
7730 }
7731
7732 bfd_boolean
7733 _bfd_elf_set_section_contents (bfd *abfd,
7734                                sec_ptr section,
7735                                const void *location,
7736                                file_ptr offset,
7737                                bfd_size_type count)
7738 {
7739   Elf_Internal_Shdr *hdr;
7740   bfd_signed_vma pos;
7741
7742   if (! abfd->output_has_begun
7743       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7744     return FALSE;
7745
7746   hdr = &elf_section_data (section)->this_hdr;
7747   pos = hdr->sh_offset + offset;
7748   if (bfd_seek (abfd, pos, SEEK_SET) != 0
7749       || bfd_bwrite (location, count, abfd) != count)
7750     return FALSE;
7751
7752   return TRUE;
7753 }
7754
7755 void
7756 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7757                            arelent *cache_ptr ATTRIBUTE_UNUSED,
7758                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7759 {
7760   abort ();
7761 }
7762
7763 /* Try to convert a non-ELF reloc into an ELF one.  */
7764
7765 bfd_boolean
7766 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7767 {
7768   /* Check whether we really have an ELF howto.  */
7769
7770   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7771     {
7772       bfd_reloc_code_real_type code;
7773       reloc_howto_type *howto;
7774
7775       /* Alien reloc: Try to determine its type to replace it with an
7776          equivalent ELF reloc.  */
7777
7778       if (areloc->howto->pc_relative)
7779         {
7780           switch (areloc->howto->bitsize)
7781             {
7782             case 8:
7783               code = BFD_RELOC_8_PCREL;
7784               break;
7785             case 12:
7786               code = BFD_RELOC_12_PCREL;
7787               break;
7788             case 16:
7789               code = BFD_RELOC_16_PCREL;
7790               break;
7791             case 24:
7792               code = BFD_RELOC_24_PCREL;
7793               break;
7794             case 32:
7795               code = BFD_RELOC_32_PCREL;
7796               break;
7797             case 64:
7798               code = BFD_RELOC_64_PCREL;
7799               break;
7800             default:
7801               goto fail;
7802             }
7803
7804           howto = bfd_reloc_type_lookup (abfd, code);
7805
7806           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7807             {
7808               if (howto->pcrel_offset)
7809                 areloc->addend += areloc->address;
7810               else
7811                 areloc->addend -= areloc->address; /* addend is unsigned!! */
7812             }
7813         }
7814       else
7815         {
7816           switch (areloc->howto->bitsize)
7817             {
7818             case 8:
7819               code = BFD_RELOC_8;
7820               break;
7821             case 14:
7822               code = BFD_RELOC_14;
7823               break;
7824             case 16:
7825               code = BFD_RELOC_16;
7826               break;
7827             case 26:
7828               code = BFD_RELOC_26;
7829               break;
7830             case 32:
7831               code = BFD_RELOC_32;
7832               break;
7833             case 64:
7834               code = BFD_RELOC_64;
7835               break;
7836             default:
7837               goto fail;
7838             }
7839
7840           howto = bfd_reloc_type_lookup (abfd, code);
7841         }
7842
7843       if (howto)
7844         areloc->howto = howto;
7845       else
7846         goto fail;
7847     }
7848
7849   return TRUE;
7850
7851  fail:
7852   (*_bfd_error_handler)
7853     (_("%B: unsupported relocation type %s"),
7854      abfd, areloc->howto->name);
7855   bfd_set_error (bfd_error_bad_value);
7856   return FALSE;
7857 }
7858
7859 bfd_boolean
7860 _bfd_elf_close_and_cleanup (bfd *abfd)
7861 {
7862   struct elf_obj_tdata *tdata = elf_tdata (abfd);
7863   if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
7864     {
7865       if (elf_shstrtab (abfd) != NULL)
7866         _bfd_elf_strtab_free (elf_shstrtab (abfd));
7867       _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
7868     }
7869
7870   return _bfd_generic_close_and_cleanup (abfd);
7871 }
7872
7873 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7874    in the relocation's offset.  Thus we cannot allow any sort of sanity
7875    range-checking to interfere.  There is nothing else to do in processing
7876    this reloc.  */
7877
7878 bfd_reloc_status_type
7879 _bfd_elf_rel_vtable_reloc_fn
7880   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7881    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7882    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7883    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7884 {
7885   return bfd_reloc_ok;
7886 }
7887 \f
7888 /* Elf core file support.  Much of this only works on native
7889    toolchains, since we rely on knowing the
7890    machine-dependent procfs structure in order to pick
7891    out details about the corefile.  */
7892
7893 #ifdef HAVE_SYS_PROCFS_H
7894 /* Needed for new procfs interface on sparc-solaris.  */
7895 # define _STRUCTURED_PROC 1
7896 # include <sys/procfs.h>
7897 #endif
7898
7899 /* Return a PID that identifies a "thread" for threaded cores, or the
7900    PID of the main process for non-threaded cores.  */
7901
7902 static int
7903 elfcore_make_pid (bfd *abfd)
7904 {
7905   int pid;
7906
7907   pid = elf_tdata (abfd)->core_lwpid;
7908   if (pid == 0)
7909     pid = elf_tdata (abfd)->core_pid;
7910
7911   return pid;
7912 }
7913
7914 /* If there isn't a section called NAME, make one, using
7915    data from SECT.  Note, this function will generate a
7916    reference to NAME, so you shouldn't deallocate or
7917    overwrite it.  */
7918
7919 static bfd_boolean
7920 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7921 {
7922   asection *sect2;
7923
7924   if (bfd_get_section_by_name (abfd, name) != NULL)
7925     return TRUE;
7926
7927   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7928   if (sect2 == NULL)
7929     return FALSE;
7930
7931   sect2->size = sect->size;
7932   sect2->filepos = sect->filepos;
7933   sect2->alignment_power = sect->alignment_power;
7934   return TRUE;
7935 }
7936
7937 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
7938    actually creates up to two pseudosections:
7939    - For the single-threaded case, a section named NAME, unless
7940      such a section already exists.
7941    - For the multi-threaded case, a section named "NAME/PID", where
7942      PID is elfcore_make_pid (abfd).
7943    Both pseudosections have identical contents. */
7944 bfd_boolean
7945 _bfd_elfcore_make_pseudosection (bfd *abfd,
7946                                  char *name,
7947                                  size_t size,
7948                                  ufile_ptr filepos)
7949 {
7950   char buf[100];
7951   char *threaded_name;
7952   size_t len;
7953   asection *sect;
7954
7955   /* Build the section name.  */
7956
7957   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7958   len = strlen (buf) + 1;
7959   threaded_name = (char *) bfd_alloc (abfd, len);
7960   if (threaded_name == NULL)
7961     return FALSE;
7962   memcpy (threaded_name, buf, len);
7963
7964   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7965                                              SEC_HAS_CONTENTS);
7966   if (sect == NULL)
7967     return FALSE;
7968   sect->size = size;
7969   sect->filepos = filepos;
7970   sect->alignment_power = 2;
7971
7972   return elfcore_maybe_make_sect (abfd, name, sect);
7973 }
7974
7975 /* prstatus_t exists on:
7976      solaris 2.5+
7977      linux 2.[01] + glibc
7978      unixware 4.2
7979 */
7980
7981 #if defined (HAVE_PRSTATUS_T)
7982
7983 static bfd_boolean
7984 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7985 {
7986   size_t size;
7987   int offset;
7988
7989   if (note->descsz == sizeof (prstatus_t))
7990     {
7991       prstatus_t prstat;
7992
7993       size = sizeof (prstat.pr_reg);
7994       offset   = offsetof (prstatus_t, pr_reg);
7995       memcpy (&prstat, note->descdata, sizeof (prstat));
7996
7997       /* Do not overwrite the core signal if it
7998          has already been set by another thread.  */
7999       if (elf_tdata (abfd)->core_signal == 0)
8000         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
8001       if (elf_tdata (abfd)->core_pid == 0)
8002         elf_tdata (abfd)->core_pid = prstat.pr_pid;
8003
8004       /* pr_who exists on:
8005          solaris 2.5+
8006          unixware 4.2
8007          pr_who doesn't exist on:
8008          linux 2.[01]
8009          */
8010 #if defined (HAVE_PRSTATUS_T_PR_WHO)
8011       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
8012 #else
8013       elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
8014 #endif
8015     }
8016 #if defined (HAVE_PRSTATUS32_T)
8017   else if (note->descsz == sizeof (prstatus32_t))
8018     {
8019       /* 64-bit host, 32-bit corefile */
8020       prstatus32_t prstat;
8021
8022       size = sizeof (prstat.pr_reg);
8023       offset   = offsetof (prstatus32_t, pr_reg);
8024       memcpy (&prstat, note->descdata, sizeof (prstat));
8025
8026       /* Do not overwrite the core signal if it
8027          has already been set by another thread.  */
8028       if (elf_tdata (abfd)->core_signal == 0)
8029         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
8030       if (elf_tdata (abfd)->core_pid == 0)
8031         elf_tdata (abfd)->core_pid = prstat.pr_pid;
8032
8033       /* pr_who exists on:
8034          solaris 2.5+
8035          unixware 4.2
8036          pr_who doesn't exist on:
8037          linux 2.[01]
8038          */
8039 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
8040       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
8041 #else
8042       elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
8043 #endif
8044     }
8045 #endif /* HAVE_PRSTATUS32_T */
8046   else
8047     {
8048       /* Fail - we don't know how to handle any other
8049          note size (ie. data object type).  */
8050       return TRUE;
8051     }
8052
8053   /* Make a ".reg/999" section and a ".reg" section.  */
8054   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
8055                                           size, note->descpos + offset);
8056 }
8057 #endif /* defined (HAVE_PRSTATUS_T) */
8058
8059 /* Create a pseudosection containing the exact contents of NOTE.  */
8060 static bfd_boolean
8061 elfcore_make_note_pseudosection (bfd *abfd,
8062                                  char *name,
8063                                  Elf_Internal_Note *note)
8064 {
8065   return _bfd_elfcore_make_pseudosection (abfd, name,
8066                                           note->descsz, note->descpos);
8067 }
8068
8069 /* There isn't a consistent prfpregset_t across platforms,
8070    but it doesn't matter, because we don't have to pick this
8071    data structure apart.  */
8072
8073 static bfd_boolean
8074 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
8075 {
8076   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8077 }
8078
8079 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
8080    type of NT_PRXFPREG.  Just include the whole note's contents
8081    literally.  */
8082
8083 static bfd_boolean
8084 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
8085 {
8086   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8087 }
8088
8089 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
8090    with a note type of NT_X86_XSTATE.  Just include the whole note's
8091    contents literally.  */
8092
8093 static bfd_boolean
8094 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
8095 {
8096   return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
8097 }
8098
8099 static bfd_boolean
8100 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
8101 {
8102   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
8103 }
8104
8105 static bfd_boolean
8106 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
8107 {
8108   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
8109 }
8110
8111 static bfd_boolean
8112 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
8113 {
8114   return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
8115 }
8116
8117 static bfd_boolean
8118 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
8119 {
8120   return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
8121 }
8122
8123 static bfd_boolean
8124 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
8125 {
8126   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
8127 }
8128
8129 static bfd_boolean
8130 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
8131 {
8132   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
8133 }
8134
8135 static bfd_boolean
8136 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
8137 {
8138   return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
8139 }
8140
8141 static bfd_boolean
8142 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
8143 {
8144   return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
8145 }
8146
8147 static bfd_boolean
8148 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
8149 {
8150   return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
8151 }
8152
8153 static bfd_boolean
8154 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
8155 {
8156   return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
8157 }
8158
8159 static bfd_boolean
8160 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
8161 {
8162   return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
8163 }
8164
8165 #if defined (HAVE_PRPSINFO_T)
8166 typedef prpsinfo_t   elfcore_psinfo_t;
8167 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
8168 typedef prpsinfo32_t elfcore_psinfo32_t;
8169 #endif
8170 #endif
8171
8172 #if defined (HAVE_PSINFO_T)
8173 typedef psinfo_t   elfcore_psinfo_t;
8174 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
8175 typedef psinfo32_t elfcore_psinfo32_t;
8176 #endif
8177 #endif
8178
8179 /* return a malloc'ed copy of a string at START which is at
8180    most MAX bytes long, possibly without a terminating '\0'.
8181    the copy will always have a terminating '\0'.  */
8182
8183 char *
8184 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
8185 {
8186   char *dups;
8187   char *end = (char *) memchr (start, '\0', max);
8188   size_t len;
8189
8190   if (end == NULL)
8191     len = max;
8192   else
8193     len = end - start;
8194
8195   dups = (char *) bfd_alloc (abfd, len + 1);
8196   if (dups == NULL)
8197     return NULL;
8198
8199   memcpy (dups, start, len);
8200   dups[len] = '\0';
8201
8202   return dups;
8203 }
8204
8205 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8206 static bfd_boolean
8207 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
8208 {
8209   if (note->descsz == sizeof (elfcore_psinfo_t))
8210     {
8211       elfcore_psinfo_t psinfo;
8212
8213       memcpy (&psinfo, note->descdata, sizeof (psinfo));
8214
8215 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
8216       elf_tdata (abfd)->core_pid = psinfo.pr_pid;
8217 #endif
8218       elf_tdata (abfd)->core_program
8219         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8220                                 sizeof (psinfo.pr_fname));
8221
8222       elf_tdata (abfd)->core_command
8223         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8224                                 sizeof (psinfo.pr_psargs));
8225     }
8226 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8227   else if (note->descsz == sizeof (elfcore_psinfo32_t))
8228     {
8229       /* 64-bit host, 32-bit corefile */
8230       elfcore_psinfo32_t psinfo;
8231
8232       memcpy (&psinfo, note->descdata, sizeof (psinfo));
8233
8234 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
8235       elf_tdata (abfd)->core_pid = psinfo.pr_pid;
8236 #endif
8237       elf_tdata (abfd)->core_program
8238         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8239                                 sizeof (psinfo.pr_fname));
8240
8241       elf_tdata (abfd)->core_command
8242         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8243                                 sizeof (psinfo.pr_psargs));
8244     }
8245 #endif
8246
8247   else
8248     {
8249       /* Fail - we don't know how to handle any other
8250          note size (ie. data object type).  */
8251       return TRUE;
8252     }
8253
8254   /* Note that for some reason, a spurious space is tacked
8255      onto the end of the args in some (at least one anyway)
8256      implementations, so strip it off if it exists.  */
8257
8258   {
8259     char *command = elf_tdata (abfd)->core_command;
8260     int n = strlen (command);
8261
8262     if (0 < n && command[n - 1] == ' ')
8263       command[n - 1] = '\0';
8264   }
8265
8266   return TRUE;
8267 }
8268 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
8269
8270 #if defined (HAVE_PSTATUS_T)
8271 static bfd_boolean
8272 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
8273 {
8274   if (note->descsz == sizeof (pstatus_t)
8275 #if defined (HAVE_PXSTATUS_T)
8276       || note->descsz == sizeof (pxstatus_t)
8277 #endif
8278       )
8279     {
8280       pstatus_t pstat;
8281
8282       memcpy (&pstat, note->descdata, sizeof (pstat));
8283
8284       elf_tdata (abfd)->core_pid = pstat.pr_pid;
8285     }
8286 #if defined (HAVE_PSTATUS32_T)
8287   else if (note->descsz == sizeof (pstatus32_t))
8288     {
8289       /* 64-bit host, 32-bit corefile */
8290       pstatus32_t pstat;
8291
8292       memcpy (&pstat, note->descdata, sizeof (pstat));
8293
8294       elf_tdata (abfd)->core_pid = pstat.pr_pid;
8295     }
8296 #endif
8297   /* Could grab some more details from the "representative"
8298      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
8299      NT_LWPSTATUS note, presumably.  */
8300
8301   return TRUE;
8302 }
8303 #endif /* defined (HAVE_PSTATUS_T) */
8304
8305 #if defined (HAVE_LWPSTATUS_T)
8306 static bfd_boolean
8307 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
8308 {
8309   lwpstatus_t lwpstat;
8310   char buf[100];
8311   char *name;
8312   size_t len;
8313   asection *sect;
8314
8315   if (note->descsz != sizeof (lwpstat)
8316 #if defined (HAVE_LWPXSTATUS_T)
8317       && note->descsz != sizeof (lwpxstatus_t)
8318 #endif
8319       )
8320     return TRUE;
8321
8322   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
8323
8324   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
8325   /* Do not overwrite the core signal if it has already been set by
8326      another thread.  */
8327   if (elf_tdata (abfd)->core_signal == 0)
8328     elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
8329
8330   /* Make a ".reg/999" section.  */
8331
8332   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
8333   len = strlen (buf) + 1;
8334   name = bfd_alloc (abfd, len);
8335   if (name == NULL)
8336     return FALSE;
8337   memcpy (name, buf, len);
8338
8339   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8340   if (sect == NULL)
8341     return FALSE;
8342
8343 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8344   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
8345   sect->filepos = note->descpos
8346     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
8347 #endif
8348
8349 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8350   sect->size = sizeof (lwpstat.pr_reg);
8351   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
8352 #endif
8353
8354   sect->alignment_power = 2;
8355
8356   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
8357     return FALSE;
8358
8359   /* Make a ".reg2/999" section */
8360
8361   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
8362   len = strlen (buf) + 1;
8363   name = bfd_alloc (abfd, len);
8364   if (name == NULL)
8365     return FALSE;
8366   memcpy (name, buf, len);
8367
8368   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8369   if (sect == NULL)
8370     return FALSE;
8371
8372 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8373   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
8374   sect->filepos = note->descpos
8375     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
8376 #endif
8377
8378 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
8379   sect->size = sizeof (lwpstat.pr_fpreg);
8380   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
8381 #endif
8382
8383   sect->alignment_power = 2;
8384
8385   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
8386 }
8387 #endif /* defined (HAVE_LWPSTATUS_T) */
8388
8389 static bfd_boolean
8390 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
8391 {
8392   char buf[30];
8393   char *name;
8394   size_t len;
8395   asection *sect;
8396   int type;
8397   int is_active_thread;
8398   bfd_vma base_addr;
8399
8400   if (note->descsz < 728)
8401     return TRUE;
8402
8403   if (! CONST_STRNEQ (note->namedata, "win32"))
8404     return TRUE;
8405
8406   type = bfd_get_32 (abfd, note->descdata);
8407
8408   switch (type)
8409     {
8410     case 1 /* NOTE_INFO_PROCESS */:
8411       /* FIXME: need to add ->core_command.  */
8412       /* process_info.pid */
8413       elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
8414       /* process_info.signal */
8415       elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
8416       break;
8417
8418     case 2 /* NOTE_INFO_THREAD */:
8419       /* Make a ".reg/999" section.  */
8420       /* thread_info.tid */
8421       sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
8422
8423       len = strlen (buf) + 1;
8424       name = (char *) bfd_alloc (abfd, len);
8425       if (name == NULL)
8426         return FALSE;
8427
8428       memcpy (name, buf, len);
8429
8430       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8431       if (sect == NULL)
8432         return FALSE;
8433
8434       /* sizeof (thread_info.thread_context) */
8435       sect->size = 716;
8436       /* offsetof (thread_info.thread_context) */
8437       sect->filepos = note->descpos + 12;
8438       sect->alignment_power = 2;
8439
8440       /* thread_info.is_active_thread */
8441       is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
8442
8443       if (is_active_thread)
8444         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
8445           return FALSE;
8446       break;
8447
8448     case 3 /* NOTE_INFO_MODULE */:
8449       /* Make a ".module/xxxxxxxx" section.  */
8450       /* module_info.base_address */
8451       base_addr = bfd_get_32 (abfd, note->descdata + 4);
8452       sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
8453
8454       len = strlen (buf) + 1;
8455       name = (char *) bfd_alloc (abfd, len);
8456       if (name == NULL)
8457         return FALSE;
8458
8459       memcpy (name, buf, len);
8460
8461       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8462
8463       if (sect == NULL)
8464         return FALSE;
8465
8466       sect->size = note->descsz;
8467       sect->filepos = note->descpos;
8468       sect->alignment_power = 2;
8469       break;
8470
8471     default:
8472       return TRUE;
8473     }
8474
8475   return TRUE;
8476 }
8477
8478 static bfd_boolean
8479 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
8480 {
8481   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8482
8483   switch (note->type)
8484     {
8485     default:
8486       return TRUE;
8487
8488     case NT_PRSTATUS:
8489       if (bed->elf_backend_grok_prstatus)
8490         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
8491           return TRUE;
8492 #if defined (HAVE_PRSTATUS_T)
8493       return elfcore_grok_prstatus (abfd, note);
8494 #else
8495       return TRUE;
8496 #endif
8497
8498 #if defined (HAVE_PSTATUS_T)
8499     case NT_PSTATUS:
8500       return elfcore_grok_pstatus (abfd, note);
8501 #endif
8502
8503 #if defined (HAVE_LWPSTATUS_T)
8504     case NT_LWPSTATUS:
8505       return elfcore_grok_lwpstatus (abfd, note);
8506 #endif
8507
8508     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
8509       return elfcore_grok_prfpreg (abfd, note);
8510
8511     case NT_WIN32PSTATUS:
8512       return elfcore_grok_win32pstatus (abfd, note);
8513
8514     case NT_PRXFPREG:           /* Linux SSE extension */
8515       if (note->namesz == 6
8516           && strcmp (note->namedata, "LINUX") == 0)
8517         return elfcore_grok_prxfpreg (abfd, note);
8518       else
8519         return TRUE;
8520
8521     case NT_X86_XSTATE:         /* Linux XSAVE extension */
8522       if (note->namesz == 6
8523           && strcmp (note->namedata, "LINUX") == 0)
8524         return elfcore_grok_xstatereg (abfd, note);
8525       else
8526         return TRUE;
8527
8528     case NT_PPC_VMX:
8529       if (note->namesz == 6
8530           && strcmp (note->namedata, "LINUX") == 0)
8531         return elfcore_grok_ppc_vmx (abfd, note);
8532       else
8533         return TRUE;
8534
8535     case NT_PPC_VSX:
8536       if (note->namesz == 6
8537           && strcmp (note->namedata, "LINUX") == 0)
8538         return elfcore_grok_ppc_vsx (abfd, note);
8539       else
8540         return TRUE;
8541
8542     case NT_S390_HIGH_GPRS:
8543       if (note->namesz == 6
8544           && strcmp (note->namedata, "LINUX") == 0)
8545         return elfcore_grok_s390_high_gprs (abfd, note);
8546       else
8547         return TRUE;
8548
8549     case NT_S390_TIMER:
8550       if (note->namesz == 6
8551           && strcmp (note->namedata, "LINUX") == 0)
8552         return elfcore_grok_s390_timer (abfd, note);
8553       else
8554         return TRUE;
8555
8556     case NT_S390_TODCMP:
8557       if (note->namesz == 6
8558           && strcmp (note->namedata, "LINUX") == 0)
8559         return elfcore_grok_s390_todcmp (abfd, note);
8560       else
8561         return TRUE;
8562
8563     case NT_S390_TODPREG:
8564       if (note->namesz == 6
8565           && strcmp (note->namedata, "LINUX") == 0)
8566         return elfcore_grok_s390_todpreg (abfd, note);
8567       else
8568         return TRUE;
8569
8570     case NT_S390_CTRS:
8571       if (note->namesz == 6
8572           && strcmp (note->namedata, "LINUX") == 0)
8573         return elfcore_grok_s390_ctrs (abfd, note);
8574       else
8575         return TRUE;
8576
8577     case NT_S390_PREFIX:
8578       if (note->namesz == 6
8579           && strcmp (note->namedata, "LINUX") == 0)
8580         return elfcore_grok_s390_prefix (abfd, note);
8581       else
8582         return TRUE;
8583
8584     case NT_S390_LAST_BREAK:
8585       if (note->namesz == 6
8586           && strcmp (note->namedata, "LINUX") == 0)
8587         return elfcore_grok_s390_last_break (abfd, note);
8588       else
8589         return TRUE;
8590
8591     case NT_S390_SYSTEM_CALL:
8592       if (note->namesz == 6
8593           && strcmp (note->namedata, "LINUX") == 0)
8594         return elfcore_grok_s390_system_call (abfd, note);
8595       else
8596         return TRUE;
8597
8598     case NT_ARM_VFP:
8599       if (note->namesz == 6
8600           && strcmp (note->namedata, "LINUX") == 0)
8601         return elfcore_grok_arm_vfp (abfd, note);
8602       else
8603         return TRUE;
8604
8605     case NT_PRPSINFO:
8606     case NT_PSINFO:
8607       if (bed->elf_backend_grok_psinfo)
8608         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
8609           return TRUE;
8610 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8611       return elfcore_grok_psinfo (abfd, note);
8612 #else
8613       return TRUE;
8614 #endif
8615
8616     case NT_AUXV:
8617       {
8618         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8619                                                              SEC_HAS_CONTENTS);
8620
8621         if (sect == NULL)
8622           return FALSE;
8623         sect->size = note->descsz;
8624         sect->filepos = note->descpos;
8625         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8626
8627         return TRUE;
8628       }
8629
8630     case NT_FILE:
8631       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
8632                                               note);
8633
8634     case NT_SIGINFO:
8635       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
8636                                               note);
8637     }
8638 }
8639
8640 static bfd_boolean
8641 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
8642 {
8643   elf_tdata (abfd)->build_id_size = note->descsz;
8644   elf_tdata (abfd)->build_id = (bfd_byte *) bfd_alloc (abfd, note->descsz);
8645   if (elf_tdata (abfd)->build_id == NULL)
8646     return FALSE;
8647
8648   memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
8649
8650   return TRUE;
8651 }
8652
8653 static bfd_boolean
8654 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8655 {
8656   switch (note->type)
8657     {
8658     default:
8659       return TRUE;
8660
8661     case NT_GNU_BUILD_ID:
8662       return elfobj_grok_gnu_build_id (abfd, note);
8663     }
8664 }
8665
8666 static bfd_boolean
8667 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
8668 {
8669   struct sdt_note *cur =
8670     (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
8671                                    + note->descsz);
8672
8673   cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
8674   cur->size = (bfd_size_type) note->descsz;
8675   memcpy (cur->data, note->descdata, note->descsz);
8676
8677   elf_tdata (abfd)->sdt_note_head = cur;
8678
8679   return TRUE;
8680 }
8681
8682 static bfd_boolean
8683 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
8684 {
8685   switch (note->type)
8686     {
8687     case NT_STAPSDT:
8688       return elfobj_grok_stapsdt_note_1 (abfd, note);
8689
8690     default:
8691       return TRUE;
8692     }
8693 }
8694
8695 static bfd_boolean
8696 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
8697 {
8698   char *cp;
8699
8700   cp = strchr (note->namedata, '@');
8701   if (cp != NULL)
8702     {
8703       *lwpidp = atoi(cp + 1);
8704       return TRUE;
8705     }
8706   return FALSE;
8707 }
8708
8709 static bfd_boolean
8710 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8711 {
8712   /* Signal number at offset 0x08. */
8713   elf_tdata (abfd)->core_signal
8714     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8715
8716   /* Process ID at offset 0x50. */
8717   elf_tdata (abfd)->core_pid
8718     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8719
8720   /* Command name at 0x7c (max 32 bytes, including nul). */
8721   elf_tdata (abfd)->core_command
8722     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8723
8724   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8725                                           note);
8726 }
8727
8728 static bfd_boolean
8729 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
8730 {
8731   int lwp;
8732
8733   if (elfcore_netbsd_get_lwpid (note, &lwp))
8734     elf_tdata (abfd)->core_lwpid = lwp;
8735
8736   if (note->type == NT_NETBSDCORE_PROCINFO)
8737     {
8738       /* NetBSD-specific core "procinfo".  Note that we expect to
8739          find this note before any of the others, which is fine,
8740          since the kernel writes this note out first when it
8741          creates a core file.  */
8742
8743       return elfcore_grok_netbsd_procinfo (abfd, note);
8744     }
8745
8746   /* As of Jan 2002 there are no other machine-independent notes
8747      defined for NetBSD core files.  If the note type is less
8748      than the start of the machine-dependent note types, we don't
8749      understand it.  */
8750
8751   if (note->type < NT_NETBSDCORE_FIRSTMACH)
8752     return TRUE;
8753
8754
8755   switch (bfd_get_arch (abfd))
8756     {
8757       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8758          PT_GETFPREGS == mach+2.  */
8759
8760     case bfd_arch_alpha:
8761     case bfd_arch_sparc:
8762       switch (note->type)
8763         {
8764         case NT_NETBSDCORE_FIRSTMACH+0:
8765           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8766
8767         case NT_NETBSDCORE_FIRSTMACH+2:
8768           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8769
8770         default:
8771           return TRUE;
8772         }
8773
8774       /* On all other arch's, PT_GETREGS == mach+1 and
8775          PT_GETFPREGS == mach+3.  */
8776
8777     default:
8778       switch (note->type)
8779         {
8780         case NT_NETBSDCORE_FIRSTMACH+1:
8781           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8782
8783         case NT_NETBSDCORE_FIRSTMACH+3:
8784           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8785
8786         default:
8787           return TRUE;
8788         }
8789     }
8790     /* NOTREACHED */
8791 }
8792
8793 static bfd_boolean
8794 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8795 {
8796   /* Signal number at offset 0x08. */
8797   elf_tdata (abfd)->core_signal
8798     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8799
8800   /* Process ID at offset 0x20. */
8801   elf_tdata (abfd)->core_pid
8802     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
8803
8804   /* Command name at 0x48 (max 32 bytes, including nul). */
8805   elf_tdata (abfd)->core_command
8806     = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
8807
8808   return TRUE;
8809 }
8810
8811 static bfd_boolean
8812 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
8813 {
8814   if (note->type == NT_OPENBSD_PROCINFO)
8815     return elfcore_grok_openbsd_procinfo (abfd, note);
8816
8817   if (note->type == NT_OPENBSD_REGS)
8818     return elfcore_make_note_pseudosection (abfd, ".reg", note);
8819
8820   if (note->type == NT_OPENBSD_FPREGS)
8821     return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8822
8823   if (note->type == NT_OPENBSD_XFPREGS)
8824     return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8825
8826   if (note->type == NT_OPENBSD_AUXV)
8827     {
8828       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8829                                                            SEC_HAS_CONTENTS);
8830
8831       if (sect == NULL)
8832         return FALSE;
8833       sect->size = note->descsz;
8834       sect->filepos = note->descpos;
8835       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8836
8837       return TRUE;
8838     }
8839
8840   if (note->type == NT_OPENBSD_WCOOKIE)
8841     {
8842       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
8843                                                            SEC_HAS_CONTENTS);
8844
8845       if (sect == NULL)
8846         return FALSE;
8847       sect->size = note->descsz;
8848       sect->filepos = note->descpos;
8849       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8850
8851       return TRUE;
8852     }
8853
8854   return TRUE;
8855 }
8856
8857 static bfd_boolean
8858 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8859 {
8860   void *ddata = note->descdata;
8861   char buf[100];
8862   char *name;
8863   asection *sect;
8864   short sig;
8865   unsigned flags;
8866
8867   /* nto_procfs_status 'pid' field is at offset 0.  */
8868   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8869
8870   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
8871   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8872
8873   /* nto_procfs_status 'flags' field is at offset 8.  */
8874   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8875
8876   /* nto_procfs_status 'what' field is at offset 14.  */
8877   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8878     {
8879       elf_tdata (abfd)->core_signal = sig;
8880       elf_tdata (abfd)->core_lwpid = *tid;
8881     }
8882
8883   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
8884      do not come from signals so we make sure we set the current
8885      thread just in case.  */
8886   if (flags & 0x00000080)
8887     elf_tdata (abfd)->core_lwpid = *tid;
8888
8889   /* Make a ".qnx_core_status/%d" section.  */
8890   sprintf (buf, ".qnx_core_status/%ld", *tid);
8891
8892   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8893   if (name == NULL)
8894     return FALSE;
8895   strcpy (name, buf);
8896
8897   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8898   if (sect == NULL)
8899     return FALSE;
8900
8901   sect->size            = note->descsz;
8902   sect->filepos         = note->descpos;
8903   sect->alignment_power = 2;
8904
8905   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8906 }
8907
8908 static bfd_boolean
8909 elfcore_grok_nto_regs (bfd *abfd,
8910                        Elf_Internal_Note *note,
8911                        long tid,
8912                        char *base)
8913 {
8914   char buf[100];
8915   char *name;
8916   asection *sect;
8917
8918   /* Make a "(base)/%d" section.  */
8919   sprintf (buf, "%s/%ld", base, tid);
8920
8921   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8922   if (name == NULL)
8923     return FALSE;
8924   strcpy (name, buf);
8925
8926   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8927   if (sect == NULL)
8928     return FALSE;
8929
8930   sect->size            = note->descsz;
8931   sect->filepos         = note->descpos;
8932   sect->alignment_power = 2;
8933
8934   /* This is the current thread.  */
8935   if (elf_tdata (abfd)->core_lwpid == tid)
8936     return elfcore_maybe_make_sect (abfd, base, sect);
8937
8938   return TRUE;
8939 }
8940
8941 #define BFD_QNT_CORE_INFO       7
8942 #define BFD_QNT_CORE_STATUS     8
8943 #define BFD_QNT_CORE_GREG       9
8944 #define BFD_QNT_CORE_FPREG      10
8945
8946 static bfd_boolean
8947 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8948 {
8949   /* Every GREG section has a STATUS section before it.  Store the
8950      tid from the previous call to pass down to the next gregs
8951      function.  */
8952   static long tid = 1;
8953
8954   switch (note->type)
8955     {
8956     case BFD_QNT_CORE_INFO:
8957       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8958     case BFD_QNT_CORE_STATUS:
8959       return elfcore_grok_nto_status (abfd, note, &tid);
8960     case BFD_QNT_CORE_GREG:
8961       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8962     case BFD_QNT_CORE_FPREG:
8963       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8964     default:
8965       return TRUE;
8966     }
8967 }
8968
8969 static bfd_boolean
8970 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8971 {
8972   char *name;
8973   asection *sect;
8974   size_t len;
8975
8976   /* Use note name as section name.  */
8977   len = note->namesz;
8978   name = (char *) bfd_alloc (abfd, len);
8979   if (name == NULL)
8980     return FALSE;
8981   memcpy (name, note->namedata, len);
8982   name[len - 1] = '\0';
8983
8984   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8985   if (sect == NULL)
8986     return FALSE;
8987
8988   sect->size            = note->descsz;
8989   sect->filepos         = note->descpos;
8990   sect->alignment_power = 1;
8991
8992   return TRUE;
8993 }
8994
8995 /* Function: elfcore_write_note
8996
8997    Inputs:
8998      buffer to hold note, and current size of buffer
8999      name of note
9000      type of note
9001      data for note
9002      size of data for note
9003
9004    Writes note to end of buffer.  ELF64 notes are written exactly as
9005    for ELF32, despite the current (as of 2006) ELF gabi specifying
9006    that they ought to have 8-byte namesz and descsz field, and have
9007    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
9008
9009    Return:
9010    Pointer to realloc'd buffer, *BUFSIZ updated.  */
9011
9012 char *
9013 elfcore_write_note (bfd *abfd,
9014                     char *buf,
9015                     int *bufsiz,
9016                     const char *name,
9017                     int type,
9018                     const void *input,
9019                     int size)
9020 {
9021   Elf_External_Note *xnp;
9022   size_t namesz;
9023   size_t newspace;
9024   char *dest;
9025
9026   namesz = 0;
9027   if (name != NULL)
9028     namesz = strlen (name) + 1;
9029
9030   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
9031
9032   buf = (char *) realloc (buf, *bufsiz + newspace);
9033   if (buf == NULL)
9034     return buf;
9035   dest = buf + *bufsiz;
9036   *bufsiz += newspace;
9037   xnp = (Elf_External_Note *) dest;
9038   H_PUT_32 (abfd, namesz, xnp->namesz);
9039   H_PUT_32 (abfd, size, xnp->descsz);
9040   H_PUT_32 (abfd, type, xnp->type);
9041   dest = xnp->name;
9042   if (name != NULL)
9043     {
9044       memcpy (dest, name, namesz);
9045       dest += namesz;
9046       while (namesz & 3)
9047         {
9048           *dest++ = '\0';
9049           ++namesz;
9050         }
9051     }
9052   memcpy (dest, input, size);
9053   dest += size;
9054   while (size & 3)
9055     {
9056       *dest++ = '\0';
9057       ++size;
9058     }
9059   return buf;
9060 }
9061
9062 char *
9063 elfcore_write_prpsinfo (bfd  *abfd,
9064                         char *buf,
9065                         int  *bufsiz,
9066                         const char *fname,
9067                         const char *psargs)
9068 {
9069   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9070
9071   if (bed->elf_backend_write_core_note != NULL)
9072     {
9073       char *ret;
9074       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
9075                                                  NT_PRPSINFO, fname, psargs);
9076       if (ret != NULL)
9077         return ret;
9078     }
9079
9080 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9081 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9082   if (bed->s->elfclass == ELFCLASS32)
9083     {
9084 #if defined (HAVE_PSINFO32_T)
9085       psinfo32_t data;
9086       int note_type = NT_PSINFO;
9087 #else
9088       prpsinfo32_t data;
9089       int note_type = NT_PRPSINFO;
9090 #endif
9091
9092       memset (&data, 0, sizeof (data));
9093       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
9094       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
9095       return elfcore_write_note (abfd, buf, bufsiz,
9096                                  "CORE", note_type, &data, sizeof (data));
9097     }
9098   else
9099 #endif
9100     {
9101 #if defined (HAVE_PSINFO_T)
9102       psinfo_t data;
9103       int note_type = NT_PSINFO;
9104 #else
9105       prpsinfo_t data;
9106       int note_type = NT_PRPSINFO;
9107 #endif
9108
9109       memset (&data, 0, sizeof (data));
9110       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
9111       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
9112       return elfcore_write_note (abfd, buf, bufsiz,
9113                                  "CORE", note_type, &data, sizeof (data));
9114     }
9115 #endif  /* PSINFO_T or PRPSINFO_T */
9116
9117   free (buf);
9118   return NULL;
9119 }
9120
9121 char *
9122 elfcore_write_prstatus (bfd *abfd,
9123                         char *buf,
9124                         int *bufsiz,
9125                         long pid,
9126                         int cursig,
9127                         const void *gregs)
9128 {
9129   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9130
9131   if (bed->elf_backend_write_core_note != NULL)
9132     {
9133       char *ret;
9134       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
9135                                                  NT_PRSTATUS,
9136                                                  pid, cursig, gregs);
9137       if (ret != NULL)
9138         return ret;
9139     }
9140
9141 #if defined (HAVE_PRSTATUS_T)
9142 #if defined (HAVE_PRSTATUS32_T)
9143   if (bed->s->elfclass == ELFCLASS32)
9144     {
9145       prstatus32_t prstat;
9146
9147       memset (&prstat, 0, sizeof (prstat));
9148       prstat.pr_pid = pid;
9149       prstat.pr_cursig = cursig;
9150       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
9151       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
9152                                  NT_PRSTATUS, &prstat, sizeof (prstat));
9153     }
9154   else
9155 #endif
9156     {
9157       prstatus_t prstat;
9158
9159       memset (&prstat, 0, sizeof (prstat));
9160       prstat.pr_pid = pid;
9161       prstat.pr_cursig = cursig;
9162       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
9163       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
9164                                  NT_PRSTATUS, &prstat, sizeof (prstat));
9165     }
9166 #endif /* HAVE_PRSTATUS_T */
9167
9168   free (buf);
9169   return NULL;
9170 }
9171
9172 #if defined (HAVE_LWPSTATUS_T)
9173 char *
9174 elfcore_write_lwpstatus (bfd *abfd,
9175                          char *buf,
9176                          int *bufsiz,
9177                          long pid,
9178                          int cursig,
9179                          const void *gregs)
9180 {
9181   lwpstatus_t lwpstat;
9182   const char *note_name = "CORE";
9183
9184   memset (&lwpstat, 0, sizeof (lwpstat));
9185   lwpstat.pr_lwpid  = pid >> 16;
9186   lwpstat.pr_cursig = cursig;
9187 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9188   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
9189 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9190 #if !defined(gregs)
9191   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
9192           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
9193 #else
9194   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
9195           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
9196 #endif
9197 #endif
9198   return elfcore_write_note (abfd, buf, bufsiz, note_name,
9199                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
9200 }
9201 #endif /* HAVE_LWPSTATUS_T */
9202
9203 #if defined (HAVE_PSTATUS_T)
9204 char *
9205 elfcore_write_pstatus (bfd *abfd,
9206                        char *buf,
9207                        int *bufsiz,
9208                        long pid,
9209                        int cursig ATTRIBUTE_UNUSED,
9210                        const void *gregs ATTRIBUTE_UNUSED)
9211 {
9212   const char *note_name = "CORE";
9213 #if defined (HAVE_PSTATUS32_T)
9214   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9215
9216   if (bed->s->elfclass == ELFCLASS32)
9217     {
9218       pstatus32_t pstat;
9219
9220       memset (&pstat, 0, sizeof (pstat));
9221       pstat.pr_pid = pid & 0xffff;
9222       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9223                                 NT_PSTATUS, &pstat, sizeof (pstat));
9224       return buf;
9225     }
9226   else
9227 #endif
9228     {
9229       pstatus_t pstat;
9230
9231       memset (&pstat, 0, sizeof (pstat));
9232       pstat.pr_pid = pid & 0xffff;
9233       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9234                                 NT_PSTATUS, &pstat, sizeof (pstat));
9235       return buf;
9236     }
9237 }
9238 #endif /* HAVE_PSTATUS_T */
9239
9240 char *
9241 elfcore_write_prfpreg (bfd *abfd,
9242                        char *buf,
9243                        int *bufsiz,
9244                        const void *fpregs,
9245                        int size)
9246 {
9247   const char *note_name = "CORE";
9248   return elfcore_write_note (abfd, buf, bufsiz,
9249                              note_name, NT_FPREGSET, fpregs, size);
9250 }
9251
9252 char *
9253 elfcore_write_prxfpreg (bfd *abfd,
9254                         char *buf,
9255                         int *bufsiz,
9256                         const void *xfpregs,
9257                         int size)
9258 {
9259   char *note_name = "LINUX";
9260   return elfcore_write_note (abfd, buf, bufsiz,
9261                              note_name, NT_PRXFPREG, xfpregs, size);
9262 }
9263
9264 char *
9265 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
9266                          const void *xfpregs, int size)
9267 {
9268   char *note_name = "LINUX";
9269   return elfcore_write_note (abfd, buf, bufsiz,
9270                              note_name, NT_X86_XSTATE, xfpregs, size);
9271 }
9272
9273 char *
9274 elfcore_write_ppc_vmx (bfd *abfd,
9275                        char *buf,
9276                        int *bufsiz,
9277                        const void *ppc_vmx,
9278                        int size)
9279 {
9280   char *note_name = "LINUX";
9281   return elfcore_write_note (abfd, buf, bufsiz,
9282                              note_name, NT_PPC_VMX, ppc_vmx, size);
9283 }
9284
9285 char *
9286 elfcore_write_ppc_vsx (bfd *abfd,
9287                        char *buf,
9288                        int *bufsiz,
9289                        const void *ppc_vsx,
9290                        int size)
9291 {
9292   char *note_name = "LINUX";
9293   return elfcore_write_note (abfd, buf, bufsiz,
9294                              note_name, NT_PPC_VSX, ppc_vsx, size);
9295 }
9296
9297 static char *
9298 elfcore_write_s390_high_gprs (bfd *abfd,
9299                               char *buf,
9300                               int *bufsiz,
9301                               const void *s390_high_gprs,
9302                               int size)
9303 {
9304   char *note_name = "LINUX";
9305   return elfcore_write_note (abfd, buf, bufsiz,
9306                              note_name, NT_S390_HIGH_GPRS,
9307                              s390_high_gprs, size);
9308 }
9309
9310 char *
9311 elfcore_write_s390_timer (bfd *abfd,
9312                           char *buf,
9313                           int *bufsiz,
9314                           const void *s390_timer,
9315                           int size)
9316 {
9317   char *note_name = "LINUX";
9318   return elfcore_write_note (abfd, buf, bufsiz,
9319                              note_name, NT_S390_TIMER, s390_timer, size);
9320 }
9321
9322 char *
9323 elfcore_write_s390_todcmp (bfd *abfd,
9324                            char *buf,
9325                            int *bufsiz,
9326                            const void *s390_todcmp,
9327                            int size)
9328 {
9329   char *note_name = "LINUX";
9330   return elfcore_write_note (abfd, buf, bufsiz,
9331                              note_name, NT_S390_TODCMP, s390_todcmp, size);
9332 }
9333
9334 char *
9335 elfcore_write_s390_todpreg (bfd *abfd,
9336                             char *buf,
9337                             int *bufsiz,
9338                             const void *s390_todpreg,
9339                             int size)
9340 {
9341   char *note_name = "LINUX";
9342   return elfcore_write_note (abfd, buf, bufsiz,
9343                              note_name, NT_S390_TODPREG, s390_todpreg, size);
9344 }
9345
9346 char *
9347 elfcore_write_s390_ctrs (bfd *abfd,
9348                          char *buf,
9349                          int *bufsiz,
9350                          const void *s390_ctrs,
9351                          int size)
9352 {
9353   char *note_name = "LINUX";
9354   return elfcore_write_note (abfd, buf, bufsiz,
9355                              note_name, NT_S390_CTRS, s390_ctrs, size);
9356 }
9357
9358 char *
9359 elfcore_write_s390_prefix (bfd *abfd,
9360                            char *buf,
9361                            int *bufsiz,
9362                            const void *s390_prefix,
9363                            int size)
9364 {
9365   char *note_name = "LINUX";
9366   return elfcore_write_note (abfd, buf, bufsiz,
9367                              note_name, NT_S390_PREFIX, s390_prefix, size);
9368 }
9369
9370 char *
9371 elfcore_write_s390_last_break (bfd *abfd,
9372                                char *buf,
9373                                int *bufsiz,
9374                                const void *s390_last_break,
9375                                int size)
9376 {
9377   char *note_name = "LINUX";
9378   return elfcore_write_note (abfd, buf, bufsiz,
9379                              note_name, NT_S390_LAST_BREAK,
9380                              s390_last_break, size);
9381 }
9382
9383 char *
9384 elfcore_write_s390_system_call (bfd *abfd,
9385                                 char *buf,
9386                                 int *bufsiz,
9387                                 const void *s390_system_call,
9388                                 int size)
9389 {
9390   char *note_name = "LINUX";
9391   return elfcore_write_note (abfd, buf, bufsiz,
9392                              note_name, NT_S390_SYSTEM_CALL,
9393                              s390_system_call, size);
9394 }
9395
9396 char *
9397 elfcore_write_arm_vfp (bfd *abfd,
9398                        char *buf,
9399                        int *bufsiz,
9400                        const void *arm_vfp,
9401                        int size)
9402 {
9403   char *note_name = "LINUX";
9404   return elfcore_write_note (abfd, buf, bufsiz,
9405                              note_name, NT_ARM_VFP, arm_vfp, size);
9406 }
9407
9408 char *
9409 elfcore_write_register_note (bfd *abfd,
9410                              char *buf,
9411                              int *bufsiz,
9412                              const char *section,
9413                              const void *data,
9414                              int size)
9415 {
9416   if (strcmp (section, ".reg2") == 0)
9417     return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
9418   if (strcmp (section, ".reg-xfp") == 0)
9419     return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
9420   if (strcmp (section, ".reg-xstate") == 0)
9421     return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
9422   if (strcmp (section, ".reg-ppc-vmx") == 0)
9423     return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
9424   if (strcmp (section, ".reg-ppc-vsx") == 0)
9425     return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
9426   if (strcmp (section, ".reg-s390-high-gprs") == 0)
9427     return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
9428   if (strcmp (section, ".reg-s390-timer") == 0)
9429     return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
9430   if (strcmp (section, ".reg-s390-todcmp") == 0)
9431     return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
9432   if (strcmp (section, ".reg-s390-todpreg") == 0)
9433     return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
9434   if (strcmp (section, ".reg-s390-ctrs") == 0)
9435     return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
9436   if (strcmp (section, ".reg-s390-prefix") == 0)
9437     return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
9438   if (strcmp (section, ".reg-s390-last-break") == 0)
9439     return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
9440   if (strcmp (section, ".reg-s390-system-call") == 0)
9441     return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
9442   if (strcmp (section, ".reg-arm-vfp") == 0)
9443     return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
9444   return NULL;
9445 }
9446
9447 static bfd_boolean
9448 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
9449 {
9450   char *p;
9451
9452   p = buf;
9453   while (p < buf + size)
9454     {
9455       /* FIXME: bad alignment assumption.  */
9456       Elf_External_Note *xnp = (Elf_External_Note *) p;
9457       Elf_Internal_Note in;
9458
9459       if (offsetof (Elf_External_Note, name) > buf - p + size)
9460         return FALSE;
9461
9462       in.type = H_GET_32 (abfd, xnp->type);
9463
9464       in.namesz = H_GET_32 (abfd, xnp->namesz);
9465       in.namedata = xnp->name;
9466       if (in.namesz > buf - in.namedata + size)
9467         return FALSE;
9468
9469       in.descsz = H_GET_32 (abfd, xnp->descsz);
9470       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
9471       in.descpos = offset + (in.descdata - buf);
9472       if (in.descsz != 0
9473           && (in.descdata >= buf + size
9474               || in.descsz > buf - in.descdata + size))
9475         return FALSE;
9476
9477       switch (bfd_get_format (abfd))
9478         {
9479         default:
9480           return TRUE;
9481
9482         case bfd_core:
9483           if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
9484             {
9485               if (! elfcore_grok_netbsd_note (abfd, &in))
9486                 return FALSE;
9487             }
9488           else if (CONST_STRNEQ (in.namedata, "OpenBSD"))
9489             {
9490               if (! elfcore_grok_openbsd_note (abfd, &in))
9491                 return FALSE;
9492             }
9493           else if (CONST_STRNEQ (in.namedata, "QNX"))
9494             {
9495               if (! elfcore_grok_nto_note (abfd, &in))
9496                 return FALSE;
9497             }
9498           else if (CONST_STRNEQ (in.namedata, "SPU/"))
9499             {
9500               if (! elfcore_grok_spu_note (abfd, &in))
9501                 return FALSE;
9502             }
9503           else
9504             {
9505               if (! elfcore_grok_note (abfd, &in))
9506                 return FALSE;
9507             }
9508           break;
9509
9510         case bfd_object:
9511           if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
9512             {
9513               if (! elfobj_grok_gnu_note (abfd, &in))
9514                 return FALSE;
9515             }
9516           else if (in.namesz == sizeof "stapsdt"
9517                    && strcmp (in.namedata, "stapsdt") == 0)
9518             {
9519               if (! elfobj_grok_stapsdt_note (abfd, &in))
9520                 return FALSE;
9521             }
9522           break;
9523         }
9524
9525       p = in.descdata + BFD_ALIGN (in.descsz, 4);
9526     }
9527
9528   return TRUE;
9529 }
9530
9531 static bfd_boolean
9532 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
9533 {
9534   char *buf;
9535
9536   if (size <= 0)
9537     return TRUE;
9538
9539   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
9540     return FALSE;
9541
9542   buf = (char *) bfd_malloc (size);
9543   if (buf == NULL)
9544     return FALSE;
9545
9546   if (bfd_bread (buf, size, abfd) != size
9547       || !elf_parse_notes (abfd, buf, size, offset))
9548     {
9549       free (buf);
9550       return FALSE;
9551     }
9552
9553   free (buf);
9554   return TRUE;
9555 }
9556 \f
9557 /* Providing external access to the ELF program header table.  */
9558
9559 /* Return an upper bound on the number of bytes required to store a
9560    copy of ABFD's program header table entries.  Return -1 if an error
9561    occurs; bfd_get_error will return an appropriate code.  */
9562
9563 long
9564 bfd_get_elf_phdr_upper_bound (bfd *abfd)
9565 {
9566   if (abfd->xvec->flavour != bfd_target_elf_flavour)
9567     {
9568       bfd_set_error (bfd_error_wrong_format);
9569       return -1;
9570     }
9571
9572   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
9573 }
9574
9575 /* Copy ABFD's program header table entries to *PHDRS.  The entries
9576    will be stored as an array of Elf_Internal_Phdr structures, as
9577    defined in include/elf/internal.h.  To find out how large the
9578    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9579
9580    Return the number of program header table entries read, or -1 if an
9581    error occurs; bfd_get_error will return an appropriate code.  */
9582
9583 int
9584 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
9585 {
9586   int num_phdrs;
9587
9588   if (abfd->xvec->flavour != bfd_target_elf_flavour)
9589     {
9590       bfd_set_error (bfd_error_wrong_format);
9591       return -1;
9592     }
9593
9594   num_phdrs = elf_elfheader (abfd)->e_phnum;
9595   memcpy (phdrs, elf_tdata (abfd)->phdr,
9596           num_phdrs * sizeof (Elf_Internal_Phdr));
9597
9598   return num_phdrs;
9599 }
9600
9601 enum elf_reloc_type_class
9602 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
9603 {
9604   return reloc_class_normal;
9605 }
9606
9607 /* For RELA architectures, return the relocation value for a
9608    relocation against a local symbol.  */
9609
9610 bfd_vma
9611 _bfd_elf_rela_local_sym (bfd *abfd,
9612                          Elf_Internal_Sym *sym,
9613                          asection **psec,
9614                          Elf_Internal_Rela *rel)
9615 {
9616   asection *sec = *psec;
9617   bfd_vma relocation;
9618
9619   relocation = (sec->output_section->vma
9620                 + sec->output_offset
9621                 + sym->st_value);
9622   if ((sec->flags & SEC_MERGE)
9623       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
9624       && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
9625     {
9626       rel->r_addend =
9627         _bfd_merged_section_offset (abfd, psec,
9628                                     elf_section_data (sec)->sec_info,
9629                                     sym->st_value + rel->r_addend);
9630       if (sec != *psec)
9631         {
9632           /* If we have changed the section, and our original section is
9633              marked with SEC_EXCLUDE, it means that the original
9634              SEC_MERGE section has been completely subsumed in some
9635              other SEC_MERGE section.  In this case, we need to leave
9636              some info around for --emit-relocs.  */
9637           if ((sec->flags & SEC_EXCLUDE) != 0)
9638             sec->kept_section = *psec;
9639           sec = *psec;
9640         }
9641       rel->r_addend -= relocation;
9642       rel->r_addend += sec->output_section->vma + sec->output_offset;
9643     }
9644   return relocation;
9645 }
9646
9647 bfd_vma
9648 _bfd_elf_rel_local_sym (bfd *abfd,
9649                         Elf_Internal_Sym *sym,
9650                         asection **psec,
9651                         bfd_vma addend)
9652 {
9653   asection *sec = *psec;
9654
9655   if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
9656     return sym->st_value + addend;
9657
9658   return _bfd_merged_section_offset (abfd, psec,
9659                                      elf_section_data (sec)->sec_info,
9660                                      sym->st_value + addend);
9661 }
9662
9663 bfd_vma
9664 _bfd_elf_section_offset (bfd *abfd,
9665                          struct bfd_link_info *info,
9666                          asection *sec,
9667                          bfd_vma offset)
9668 {
9669   switch (sec->sec_info_type)
9670     {
9671     case SEC_INFO_TYPE_STABS:
9672       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
9673                                        offset);
9674     case SEC_INFO_TYPE_EH_FRAME:
9675       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
9676     default:
9677       if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
9678         {
9679           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9680           bfd_size_type address_size = bed->s->arch_size / 8;
9681           offset = sec->size - offset - address_size;
9682         }
9683       return offset;
9684     }
9685 }
9686 \f
9687 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
9688    reconstruct an ELF file by reading the segments out of remote memory
9689    based on the ELF file header at EHDR_VMA and the ELF program headers it
9690    points to.  If not null, *LOADBASEP is filled in with the difference
9691    between the VMAs from which the segments were read, and the VMAs the
9692    file headers (and hence BFD's idea of each section's VMA) put them at.
9693
9694    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
9695    remote memory at target address VMA into the local buffer at MYADDR; it
9696    should return zero on success or an `errno' code on failure.  TEMPL must
9697    be a BFD for an ELF target with the word size and byte order found in
9698    the remote memory.  */
9699
9700 bfd *
9701 bfd_elf_bfd_from_remote_memory
9702   (bfd *templ,
9703    bfd_vma ehdr_vma,
9704    bfd_vma *loadbasep,
9705    int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
9706 {
9707   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
9708     (templ, ehdr_vma, loadbasep, target_read_memory);
9709 }
9710 \f
9711 long
9712 _bfd_elf_get_synthetic_symtab (bfd *abfd,
9713                                long symcount ATTRIBUTE_UNUSED,
9714                                asymbol **syms ATTRIBUTE_UNUSED,
9715                                long dynsymcount,
9716                                asymbol **dynsyms,
9717                                asymbol **ret)
9718 {
9719   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9720   asection *relplt;
9721   asymbol *s;
9722   const char *relplt_name;
9723   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
9724   arelent *p;
9725   long count, i, n;
9726   size_t size;
9727   Elf_Internal_Shdr *hdr;
9728   char *names;
9729   asection *plt;
9730
9731   *ret = NULL;
9732
9733   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
9734     return 0;
9735
9736   if (dynsymcount <= 0)
9737     return 0;
9738
9739   if (!bed->plt_sym_val)
9740     return 0;
9741
9742   relplt_name = bed->relplt_name;
9743   if (relplt_name == NULL)
9744     relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
9745   relplt = bfd_get_section_by_name (abfd, relplt_name);
9746   if (relplt == NULL)
9747     return 0;
9748
9749   hdr = &elf_section_data (relplt)->this_hdr;
9750   if (hdr->sh_link != elf_dynsymtab (abfd)
9751       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
9752     return 0;
9753
9754   plt = bfd_get_section_by_name (abfd, ".plt");
9755   if (plt == NULL)
9756     return 0;
9757
9758   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
9759   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
9760     return -1;
9761
9762   count = relplt->size / hdr->sh_entsize;
9763   size = count * sizeof (asymbol);
9764   p = relplt->relocation;
9765   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9766     {
9767       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
9768       if (p->addend != 0)
9769         {
9770 #ifdef BFD64
9771           size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
9772 #else
9773           size += sizeof ("+0x") - 1 + 8;
9774 #endif
9775         }
9776     }
9777
9778   s = *ret = (asymbol *) bfd_malloc (size);
9779   if (s == NULL)
9780     return -1;
9781
9782   names = (char *) (s + count);
9783   p = relplt->relocation;
9784   n = 0;
9785   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9786     {
9787       size_t len;
9788       bfd_vma addr;
9789
9790       addr = bed->plt_sym_val (i, plt, p);
9791       if (addr == (bfd_vma) -1)
9792         continue;
9793
9794       *s = **p->sym_ptr_ptr;
9795       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
9796          we are defining a symbol, ensure one of them is set.  */
9797       if ((s->flags & BSF_LOCAL) == 0)
9798         s->flags |= BSF_GLOBAL;
9799       s->flags |= BSF_SYNTHETIC;
9800       s->section = plt;
9801       s->value = addr - plt->vma;
9802       s->name = names;
9803       s->udata.p = NULL;
9804       len = strlen ((*p->sym_ptr_ptr)->name);
9805       memcpy (names, (*p->sym_ptr_ptr)->name, len);
9806       names += len;
9807       if (p->addend != 0)
9808         {
9809           char buf[30], *a;
9810
9811           memcpy (names, "+0x", sizeof ("+0x") - 1);
9812           names += sizeof ("+0x") - 1;
9813           bfd_sprintf_vma (abfd, buf, p->addend);
9814           for (a = buf; *a == '0'; ++a)
9815             ;
9816           len = strlen (a);
9817           memcpy (names, a, len);
9818           names += len;
9819         }
9820       memcpy (names, "@plt", sizeof ("@plt"));
9821       names += sizeof ("@plt");
9822       ++s, ++n;
9823     }
9824
9825   return n;
9826 }
9827
9828 /* It is only used by x86-64 so far.  */
9829 asection _bfd_elf_large_com_section
9830   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
9831                       SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
9832
9833 void
9834 _bfd_elf_set_osabi (bfd * abfd,
9835                     struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
9836 {
9837   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
9838
9839   i_ehdrp = elf_elfheader (abfd);
9840
9841   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
9842
9843   /* To make things simpler for the loader on Linux systems we set the
9844      osabi field to ELFOSABI_GNU if the binary contains symbols of
9845      the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding.  */
9846   if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
9847       && elf_tdata (abfd)->has_gnu_symbols)
9848     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
9849 }
9850
9851
9852 /* Return TRUE for ELF symbol types that represent functions.
9853    This is the default version of this function, which is sufficient for
9854    most targets.  It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC.  */
9855
9856 bfd_boolean
9857 _bfd_elf_is_function_type (unsigned int type)
9858 {
9859   return (type == STT_FUNC
9860           || type == STT_GNU_IFUNC);
9861 }
9862
9863 /* If the ELF symbol SYM might be a function in SEC, return the
9864    function size and set *CODE_OFF to the function's entry point,
9865    otherwise return zero.  */
9866
9867 bfd_size_type
9868 _bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
9869                              bfd_vma *code_off)
9870 {
9871   bfd_size_type size;
9872
9873   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
9874                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
9875       || sym->section != sec)
9876     return 0;
9877
9878   *code_off = sym->value;
9879   size = 0;
9880   if (!(sym->flags & BSF_SYNTHETIC))
9881     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
9882   if (size == 0)
9883     size = 1;
9884   return size;
9885 }