bfd/elf.c

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