bfd/elf.c

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