bfd/elf.c

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