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