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