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