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