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