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