bfd/elf.c

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