bfd/elf.c

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