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