bfd/elf.c

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