bfd/elf.c

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