bfd/elf.c

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