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