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