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