bfd/elf.c

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