bfd/elf.c

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