bfd/elf.c

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