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