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