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