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.  Called from
2685    _bfd_elf_compute_section_file_positions for gas, objcopy, and
2686    when ELF targets use the generic linker, ld.  Called for ld -r
2687    from bfd_elf_final_link.  */
2688
2689 void
2690 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2691 {
2692   bfd_boolean *failedptr = failedptrarg;
2693   asection *elt, *first;
2694   unsigned char *loc;
2695   bfd_boolean gas;
2696
2697   /* Ignore linker created group section.  See elfNN_ia64_object_p in
2698      elfxx-ia64.c.  */
2699   if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2700       || *failedptr)
2701     return;
2702
2703   if (elf_section_data (sec)->this_hdr.sh_info == 0)
2704     {
2705       unsigned long symindx = 0;
2706
2707       /* elf_group_id will have been set up by objcopy and the
2708          generic linker.  */
2709       if (elf_group_id (sec) != NULL)
2710         symindx = elf_group_id (sec)->udata.i;
2711
2712       if (symindx == 0)
2713         {
2714           /* If called from the assembler, swap_out_syms will have set up
2715              elf_section_syms.  */
2716           BFD_ASSERT (elf_section_syms (abfd) != NULL);
2717           symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2718         }
2719       elf_section_data (sec)->this_hdr.sh_info = symindx;
2720     }
2721   else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
2722     {
2723       /* The ELF backend linker sets sh_info to -2 when the group
2724          signature symbol is global, and thus the index can't be
2725          set until all local symbols are output.  */
2726       asection *igroup = elf_sec_group (elf_next_in_group (sec));
2727       struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
2728       unsigned long symndx = sec_data->this_hdr.sh_info;
2729       unsigned long extsymoff = 0;
2730       struct elf_link_hash_entry *h;
2731
2732       if (!elf_bad_symtab (igroup->owner))
2733         {
2734           Elf_Internal_Shdr *symtab_hdr;
2735
2736           symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
2737           extsymoff = symtab_hdr->sh_info;
2738         }
2739       h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
2740       while (h->root.type == bfd_link_hash_indirect
2741              || h->root.type == bfd_link_hash_warning)
2742         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2743
2744       elf_section_data (sec)->this_hdr.sh_info = h->indx;
2745     }
2746
2747   /* The contents won't be allocated for "ld -r" or objcopy.  */
2748   gas = TRUE;
2749   if (sec->contents == NULL)
2750     {
2751       gas = FALSE;
2752       sec->contents = bfd_alloc (abfd, sec->size);
2753
2754       /* Arrange for the section to be written out.  */
2755       elf_section_data (sec)->this_hdr.contents = sec->contents;
2756       if (sec->contents == NULL)
2757         {
2758           *failedptr = TRUE;
2759           return;
2760         }
2761     }
2762
2763   loc = sec->contents + sec->size;
2764
2765   /* Get the pointer to the first section in the group that gas
2766      squirreled away here.  objcopy arranges for this to be set to the
2767      start of the input section group.  */
2768   first = elt = elf_next_in_group (sec);
2769
2770   /* First element is a flag word.  Rest of section is elf section
2771      indices for all the sections of the group.  Write them backwards
2772      just to keep the group in the same order as given in .section
2773      directives, not that it matters.  */
2774   while (elt != NULL)
2775     {
2776       asection *s;
2777       unsigned int idx;
2778
2779       loc -= 4;
2780       s = elt;
2781       if (!gas)
2782         s = s->output_section;
2783       idx = 0;
2784       if (s != NULL)
2785         idx = elf_section_data (s)->this_idx;
2786       H_PUT_32 (abfd, idx, loc);
2787       elt = elf_next_in_group (elt);
2788       if (elt == first)
2789         break;
2790     }
2791
2792   if ((loc -= 4) != sec->contents)
2793     abort ();
2794
2795   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2796 }
2797
2798 /* Assign all ELF section numbers.  The dummy first section is handled here
2799    too.  The link/info pointers for the standard section types are filled
2800    in here too, while we're at it.  */
2801
2802 static bfd_boolean
2803 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2804 {
2805   struct elf_obj_tdata *t = elf_tdata (abfd);
2806   asection *sec;
2807   unsigned int section_number, secn;
2808   Elf_Internal_Shdr **i_shdrp;
2809   struct bfd_elf_section_data *d;
2810
2811   section_number = 1;
2812
2813   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2814
2815   /* SHT_GROUP sections are in relocatable files only.  */
2816   if (link_info == NULL || link_info->relocatable)
2817     {
2818       /* Put SHT_GROUP sections first.  */
2819       for (sec = abfd->sections; sec != NULL; sec = sec->next)
2820         {
2821           d = elf_section_data (sec);
2822
2823           if (d->this_hdr.sh_type == SHT_GROUP)
2824             {
2825               if (sec->flags & SEC_LINKER_CREATED)
2826                 {
2827                   /* Remove the linker created SHT_GROUP sections.  */
2828                   bfd_section_list_remove (abfd, sec);
2829                   abfd->section_count--;
2830                 }
2831               else
2832                 d->this_idx = section_number++;
2833             }
2834         }
2835     }
2836
2837   for (sec = abfd->sections; sec; sec = sec->next)
2838     {
2839       d = elf_section_data (sec);
2840
2841       if (d->this_hdr.sh_type != SHT_GROUP)
2842         d->this_idx = section_number++;
2843       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2844       if ((sec->flags & SEC_RELOC) == 0)
2845         d->rel_idx = 0;
2846       else
2847         {
2848           d->rel_idx = section_number++;
2849           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2850         }
2851
2852       if (d->rel_hdr2)
2853         {
2854           d->rel_idx2 = section_number++;
2855           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2856         }
2857       else
2858         d->rel_idx2 = 0;
2859     }
2860
2861   t->shstrtab_section = section_number++;
2862   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2863   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2864
2865   if (bfd_get_symcount (abfd) > 0)
2866     {
2867       t->symtab_section = section_number++;
2868       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2869       if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
2870         {
2871           t->symtab_shndx_section = section_number++;
2872           t->symtab_shndx_hdr.sh_name
2873             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2874                                                   ".symtab_shndx", FALSE);
2875           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2876             return FALSE;
2877         }
2878       t->strtab_section = section_number++;
2879       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2880     }
2881
2882   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2883   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2884
2885   elf_numsections (abfd) = section_number;
2886   elf_elfheader (abfd)->e_shnum = section_number;
2887
2888   /* Set up the list of section header pointers, in agreement with the
2889      indices.  */
2890   i_shdrp = bfd_zalloc2 (abfd, section_number, sizeof (Elf_Internal_Shdr *));
2891   if (i_shdrp == NULL)
2892     return FALSE;
2893
2894   i_shdrp[0] = bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
2895   if (i_shdrp[0] == NULL)
2896     {
2897       bfd_release (abfd, i_shdrp);
2898       return FALSE;
2899     }
2900
2901   elf_elfsections (abfd) = i_shdrp;
2902
2903   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2904   if (bfd_get_symcount (abfd) > 0)
2905     {
2906       i_shdrp[t->symtab_section] = &t->symtab_hdr;
2907       if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
2908         {
2909           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2910           t->symtab_shndx_hdr.sh_link = t->symtab_section;
2911         }
2912       i_shdrp[t->strtab_section] = &t->strtab_hdr;
2913       t->symtab_hdr.sh_link = t->strtab_section;
2914     }
2915
2916   for (sec = abfd->sections; sec; sec = sec->next)
2917     {
2918       struct bfd_elf_section_data *d = elf_section_data (sec);
2919       asection *s;
2920       const char *name;
2921
2922       i_shdrp[d->this_idx] = &d->this_hdr;
2923       if (d->rel_idx != 0)
2924         i_shdrp[d->rel_idx] = &d->rel_hdr;
2925       if (d->rel_idx2 != 0)
2926         i_shdrp[d->rel_idx2] = d->rel_hdr2;
2927
2928       /* Fill in the sh_link and sh_info fields while we're at it.  */
2929
2930       /* sh_link of a reloc section is the section index of the symbol
2931          table.  sh_info is the section index of the section to which
2932          the relocation entries apply.  */
2933       if (d->rel_idx != 0)
2934         {
2935           d->rel_hdr.sh_link = t->symtab_section;
2936           d->rel_hdr.sh_info = d->this_idx;
2937         }
2938       if (d->rel_idx2 != 0)
2939         {
2940           d->rel_hdr2->sh_link = t->symtab_section;
2941           d->rel_hdr2->sh_info = d->this_idx;
2942         }
2943
2944       /* We need to set up sh_link for SHF_LINK_ORDER.  */
2945       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
2946         {
2947           s = elf_linked_to_section (sec);
2948           if (s)
2949             {
2950               /* elf_linked_to_section points to the input section.  */
2951               if (link_info != NULL)
2952                 {
2953                   /* Check discarded linkonce section.  */
2954                   if (elf_discarded_section (s))
2955                     {
2956                       asection *kept;
2957                       (*_bfd_error_handler)
2958                         (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2959                          abfd, d->this_hdr.bfd_section,
2960                          s, s->owner);
2961                       /* Point to the kept section if it has the same
2962                          size as the discarded one.  */
2963                       kept = _bfd_elf_check_kept_section (s, link_info);
2964                       if (kept == NULL)
2965                         {
2966                           bfd_set_error (bfd_error_bad_value);
2967                           return FALSE;
2968                         }
2969                       s = kept;
2970                     }
2971
2972                   s = s->output_section;
2973                   BFD_ASSERT (s != NULL);
2974                 }
2975               else
2976                 {
2977                   /* Handle objcopy. */
2978                   if (s->output_section == NULL)
2979                     {
2980                       (*_bfd_error_handler)
2981                         (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2982                          abfd, d->this_hdr.bfd_section, s, s->owner);
2983                       bfd_set_error (bfd_error_bad_value);
2984                       return FALSE;
2985                     }
2986                   s = s->output_section;
2987                 }
2988               d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2989             }
2990           else
2991             {
2992               /* PR 290:
2993                  The Intel C compiler generates SHT_IA_64_UNWIND with
2994                  SHF_LINK_ORDER.  But it doesn't set the sh_link or
2995                  sh_info fields.  Hence we could get the situation
2996                  where s is NULL.  */
2997               const struct elf_backend_data *bed
2998                 = get_elf_backend_data (abfd);
2999               if (bed->link_order_error_handler)
3000                 bed->link_order_error_handler
3001                   (_("%B: warning: sh_link not set for section `%A'"),
3002                    abfd, sec);
3003             }
3004         }
3005
3006       switch (d->this_hdr.sh_type)
3007         {
3008         case SHT_REL:
3009         case SHT_RELA:
3010           /* A reloc section which we are treating as a normal BFD
3011              section.  sh_link is the section index of the symbol
3012              table.  sh_info is the section index of the section to
3013              which the relocation entries apply.  We assume that an
3014              allocated reloc section uses the dynamic symbol table.
3015              FIXME: How can we be sure?  */
3016           s = bfd_get_section_by_name (abfd, ".dynsym");
3017           if (s != NULL)
3018             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3019
3020           /* We look up the section the relocs apply to by name.  */
3021           name = sec->name;
3022           if (d->this_hdr.sh_type == SHT_REL)
3023             name += 4;
3024           else
3025             name += 5;
3026           s = bfd_get_section_by_name (abfd, name);
3027           if (s != NULL)
3028             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3029           break;
3030
3031         case SHT_STRTAB:
3032           /* We assume that a section named .stab*str is a stabs
3033              string section.  We look for a section with the same name
3034              but without the trailing ``str'', and set its sh_link
3035              field to point to this section.  */
3036           if (CONST_STRNEQ (sec->name, ".stab")
3037               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3038             {
3039               size_t len;
3040               char *alc;
3041
3042               len = strlen (sec->name);
3043               alc = bfd_malloc (len - 2);
3044               if (alc == NULL)
3045                 return FALSE;
3046               memcpy (alc, sec->name, len - 3);
3047               alc[len - 3] = '\0';
3048               s = bfd_get_section_by_name (abfd, alc);
3049               free (alc);
3050               if (s != NULL)
3051                 {
3052                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3053
3054                   /* This is a .stab section.  */
3055                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3056                     elf_section_data (s)->this_hdr.sh_entsize
3057                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3058                 }
3059             }
3060           break;
3061
3062         case SHT_DYNAMIC:
3063         case SHT_DYNSYM:
3064         case SHT_GNU_verneed:
3065         case SHT_GNU_verdef:
3066           /* sh_link is the section header index of the string table
3067              used for the dynamic entries, or the symbol table, or the
3068              version strings.  */
3069           s = bfd_get_section_by_name (abfd, ".dynstr");
3070           if (s != NULL)
3071             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3072           break;
3073
3074         case SHT_GNU_LIBLIST:
3075           /* sh_link is the section header index of the prelink library
3076              list used for the dynamic entries, or the symbol table, or
3077              the version strings.  */
3078           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3079                                              ? ".dynstr" : ".gnu.libstr");
3080           if (s != NULL)
3081             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3082           break;
3083
3084         case SHT_HASH:
3085         case SHT_GNU_HASH:
3086         case SHT_GNU_versym:
3087           /* sh_link is the section header index of the symbol table
3088              this hash table or version table is for.  */
3089           s = bfd_get_section_by_name (abfd, ".dynsym");
3090           if (s != NULL)
3091             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3092           break;
3093
3094         case SHT_GROUP:
3095           d->this_hdr.sh_link = t->symtab_section;
3096         }
3097     }
3098
3099   for (secn = 1; secn < section_number; ++secn)
3100     if (i_shdrp[secn] == NULL)
3101       i_shdrp[secn] = i_shdrp[0];
3102     else
3103       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3104                                                        i_shdrp[secn]->sh_name);
3105   return TRUE;
3106 }
3107
3108 /* Map symbol from it's internal number to the external number, moving
3109    all local symbols to be at the head of the list.  */
3110
3111 static bfd_boolean
3112 sym_is_global (bfd *abfd, asymbol *sym)
3113 {
3114   /* If the backend has a special mapping, use it.  */
3115   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3116   if (bed->elf_backend_sym_is_global)
3117     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3118
3119   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3120           || bfd_is_und_section (bfd_get_section (sym))
3121           || bfd_is_com_section (bfd_get_section (sym)));
3122 }
3123
3124 /* Don't output section symbols for sections that are not going to be
3125    output.  */
3126
3127 static bfd_boolean
3128 ignore_section_sym (bfd *abfd, asymbol *sym)
3129 {
3130   return ((sym->flags & BSF_SECTION_SYM) != 0
3131           && !(sym->section->owner == abfd
3132                || (sym->section->output_section->owner == abfd
3133                    && sym->section->output_offset == 0)));
3134 }
3135
3136 static bfd_boolean
3137 elf_map_symbols (bfd *abfd)
3138 {
3139   unsigned int symcount = bfd_get_symcount (abfd);
3140   asymbol **syms = bfd_get_outsymbols (abfd);
3141   asymbol **sect_syms;
3142   unsigned int num_locals = 0;
3143   unsigned int num_globals = 0;
3144   unsigned int num_locals2 = 0;
3145   unsigned int num_globals2 = 0;
3146   int max_index = 0;
3147   unsigned int idx;
3148   asection *asect;
3149   asymbol **new_syms;
3150
3151 #ifdef DEBUG
3152   fprintf (stderr, "elf_map_symbols\n");
3153   fflush (stderr);
3154 #endif
3155
3156   for (asect = abfd->sections; asect; asect = asect->next)
3157     {
3158       if (max_index < asect->index)
3159         max_index = asect->index;
3160     }
3161
3162   max_index++;
3163   sect_syms = bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3164   if (sect_syms == NULL)
3165     return FALSE;
3166   elf_section_syms (abfd) = sect_syms;
3167   elf_num_section_syms (abfd) = max_index;
3168
3169   /* Init sect_syms entries for any section symbols we have already
3170      decided to output.  */
3171   for (idx = 0; idx < symcount; idx++)
3172     {
3173       asymbol *sym = syms[idx];
3174
3175       if ((sym->flags & BSF_SECTION_SYM) != 0
3176           && sym->value == 0
3177           && !ignore_section_sym (abfd, sym))
3178         {
3179           asection *sec = sym->section;
3180
3181           if (sec->owner != abfd)
3182             sec = sec->output_section;
3183
3184           sect_syms[sec->index] = syms[idx];
3185         }
3186     }
3187
3188   /* Classify all of the symbols.  */
3189   for (idx = 0; idx < symcount; idx++)
3190     {
3191       if (ignore_section_sym (abfd, syms[idx]))
3192         continue;
3193       if (!sym_is_global (abfd, syms[idx]))
3194         num_locals++;
3195       else
3196         num_globals++;
3197     }
3198
3199   /* We will be adding a section symbol for each normal BFD section.  Most
3200      sections will already have a section symbol in outsymbols, but
3201      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3202      at least in that case.  */
3203   for (asect = abfd->sections; asect; asect = asect->next)
3204     {
3205       if (sect_syms[asect->index] == NULL)
3206         {
3207           if (!sym_is_global (abfd, asect->symbol))
3208             num_locals++;
3209           else
3210             num_globals++;
3211         }
3212     }
3213
3214   /* Now sort the symbols so the local symbols are first.  */
3215   new_syms = bfd_alloc2 (abfd, num_locals + num_globals, sizeof (asymbol *));
3216
3217   if (new_syms == NULL)
3218     return FALSE;
3219
3220   for (idx = 0; idx < symcount; idx++)
3221     {
3222       asymbol *sym = syms[idx];
3223       unsigned int i;
3224
3225       if (ignore_section_sym (abfd, sym))
3226         continue;
3227       if (!sym_is_global (abfd, sym))
3228         i = num_locals2++;
3229       else
3230         i = num_locals + num_globals2++;
3231       new_syms[i] = sym;
3232       sym->udata.i = i + 1;
3233     }
3234   for (asect = abfd->sections; asect; asect = asect->next)
3235     {
3236       if (sect_syms[asect->index] == NULL)
3237         {
3238           asymbol *sym = asect->symbol;
3239           unsigned int i;
3240
3241           sect_syms[asect->index] = sym;
3242           if (!sym_is_global (abfd, sym))
3243             i = num_locals2++;
3244           else
3245             i = num_locals + num_globals2++;
3246           new_syms[i] = sym;
3247           sym->udata.i = i + 1;
3248         }
3249     }
3250
3251   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3252
3253   elf_num_locals (abfd) = num_locals;
3254   elf_num_globals (abfd) = num_globals;
3255   return TRUE;
3256 }
3257
3258 /* Align to the maximum file alignment that could be required for any
3259    ELF data structure.  */
3260
3261 static inline file_ptr
3262 align_file_position (file_ptr off, int align)
3263 {
3264   return (off + align - 1) & ~(align - 1);
3265 }
3266
3267 /* Assign a file position to a section, optionally aligning to the
3268    required section alignment.  */
3269
3270 file_ptr
3271 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3272                                            file_ptr offset,
3273                                            bfd_boolean align)
3274 {
3275   if (align && i_shdrp->sh_addralign > 1)
3276     offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
3277   i_shdrp->sh_offset = offset;
3278   if (i_shdrp->bfd_section != NULL)
3279     i_shdrp->bfd_section->filepos = offset;
3280   if (i_shdrp->sh_type != SHT_NOBITS)
3281     offset += i_shdrp->sh_size;
3282   return offset;
3283 }
3284
3285 /* Compute the file positions we are going to put the sections at, and
3286    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3287    is not NULL, this is being called by the ELF backend linker.  */
3288
3289 bfd_boolean
3290 _bfd_elf_compute_section_file_positions (bfd *abfd,
3291                                          struct bfd_link_info *link_info)
3292 {
3293   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3294   bfd_boolean failed;
3295   struct bfd_strtab_hash *strtab = NULL;
3296   Elf_Internal_Shdr *shstrtab_hdr;
3297
3298   if (abfd->output_has_begun)
3299     return TRUE;
3300
3301   /* Do any elf backend specific processing first.  */
3302   if (bed->elf_backend_begin_write_processing)
3303     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3304
3305   if (! prep_headers (abfd))
3306     return FALSE;
3307
3308   /* Post process the headers if necessary.  */
3309   if (bed->elf_backend_post_process_headers)
3310     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3311
3312   failed = FALSE;
3313   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3314   if (failed)
3315     return FALSE;
3316
3317   if (!assign_section_numbers (abfd, link_info))
3318     return FALSE;
3319
3320   /* The backend linker builds symbol table information itself.  */
3321   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3322     {
3323       /* Non-zero if doing a relocatable link.  */
3324       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3325
3326       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3327         return FALSE;
3328     }
3329
3330   if (link_info == NULL)
3331     {
3332       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3333       if (failed)
3334         return FALSE;
3335     }
3336
3337   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3338   /* sh_name was set in prep_headers.  */
3339   shstrtab_hdr->sh_type = SHT_STRTAB;
3340   shstrtab_hdr->sh_flags = 0;
3341   shstrtab_hdr->sh_addr = 0;
3342   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3343   shstrtab_hdr->sh_entsize = 0;
3344   shstrtab_hdr->sh_link = 0;
3345   shstrtab_hdr->sh_info = 0;
3346   /* sh_offset is set in assign_file_positions_except_relocs.  */
3347   shstrtab_hdr->sh_addralign = 1;
3348
3349   if (!assign_file_positions_except_relocs (abfd, link_info))
3350     return FALSE;
3351
3352   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3353     {
3354       file_ptr off;
3355       Elf_Internal_Shdr *hdr;
3356
3357       off = elf_tdata (abfd)->next_file_pos;
3358
3359       hdr = &elf_tdata (abfd)->symtab_hdr;
3360       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3361
3362       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3363       if (hdr->sh_size != 0)
3364         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3365
3366       hdr = &elf_tdata (abfd)->strtab_hdr;
3367       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3368
3369       elf_tdata (abfd)->next_file_pos = off;
3370
3371       /* Now that we know where the .strtab section goes, write it
3372          out.  */
3373       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3374           || ! _bfd_stringtab_emit (abfd, strtab))
3375         return FALSE;
3376       _bfd_stringtab_free (strtab);
3377     }
3378
3379   abfd->output_has_begun = TRUE;
3380
3381   return TRUE;
3382 }
3383
3384 /* Make an initial estimate of the size of the program header.  If we
3385    get the number wrong here, we'll redo section placement.  */
3386
3387 static bfd_size_type
3388 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3389 {
3390   size_t segs;
3391   asection *s;
3392   const struct elf_backend_data *bed;
3393
3394   /* Assume we will need exactly two PT_LOAD segments: one for text
3395      and one for data.  */
3396   segs = 2;
3397
3398   s = bfd_get_section_by_name (abfd, ".interp");
3399   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3400     {
3401       /* If we have a loadable interpreter section, we need a
3402          PT_INTERP segment.  In this case, assume we also need a
3403          PT_PHDR segment, although that may not be true for all
3404          targets.  */
3405       segs += 2;
3406     }
3407
3408   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3409     {
3410       /* We need a PT_DYNAMIC segment.  */
3411       ++segs;
3412     }
3413
3414   if (info != NULL && info->relro)
3415     {
3416       /* We need a PT_GNU_RELRO segment.  */
3417       ++segs;
3418     }
3419
3420   if (elf_tdata (abfd)->eh_frame_hdr)
3421     {
3422       /* We need a PT_GNU_EH_FRAME segment.  */
3423       ++segs;
3424     }
3425
3426   if (elf_tdata (abfd)->stack_flags)
3427     {
3428       /* We need a PT_GNU_STACK segment.  */
3429       ++segs;
3430     }
3431
3432   for (s = abfd->sections; s != NULL; s = s->next)
3433     {
3434       if ((s->flags & SEC_LOAD) != 0
3435           && CONST_STRNEQ (s->name, ".note"))
3436         {
3437           /* We need a PT_NOTE segment.  */
3438           ++segs;
3439           /* Try to create just one PT_NOTE segment
3440              for all adjacent loadable .note* sections.
3441              gABI requires that within a PT_NOTE segment
3442              (and also inside of each SHT_NOTE section)
3443              each note is padded to a multiple of 4 size,
3444              so we check whether the sections are correctly
3445              aligned.  */
3446           if (s->alignment_power == 2)
3447             while (s->next != NULL
3448                    && s->next->alignment_power == 2
3449                    && (s->next->flags & SEC_LOAD) != 0
3450                    && CONST_STRNEQ (s->next->name, ".note"))
3451               s = s->next;
3452         }
3453     }
3454
3455   for (s = abfd->sections; s != NULL; s = s->next)
3456     {
3457       if (s->flags & SEC_THREAD_LOCAL)
3458         {
3459           /* We need a PT_TLS segment.  */
3460           ++segs;
3461           break;
3462         }
3463     }
3464
3465   /* Let the backend count up any program headers it might need.  */
3466   bed = get_elf_backend_data (abfd);
3467   if (bed->elf_backend_additional_program_headers)
3468     {
3469       int a;
3470
3471       a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3472       if (a == -1)
3473         abort ();
3474       segs += a;
3475     }
3476
3477   return segs * bed->s->sizeof_phdr;
3478 }
3479
3480 /* Find the segment that contains the output_section of section.  */
3481
3482 Elf_Internal_Phdr *
3483 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3484 {
3485   struct elf_segment_map *m;
3486   Elf_Internal_Phdr *p;
3487
3488   for (m = elf_tdata (abfd)->segment_map,
3489          p = elf_tdata (abfd)->phdr;
3490        m != NULL;
3491        m = m->next, p++)
3492     {
3493       int i;
3494
3495       for (i = m->count - 1; i >= 0; i--)
3496         if (m->sections[i] == section)
3497           return p;
3498     }
3499
3500   return NULL;
3501 }
3502
3503 /* Create a mapping from a set of sections to a program segment.  */
3504
3505 static struct elf_segment_map *
3506 make_mapping (bfd *abfd,
3507               asection **sections,
3508               unsigned int from,
3509               unsigned int to,
3510               bfd_boolean phdr)
3511 {
3512   struct elf_segment_map *m;
3513   unsigned int i;
3514   asection **hdrpp;
3515   bfd_size_type amt;
3516
3517   amt = sizeof (struct elf_segment_map);
3518   amt += (to - from - 1) * sizeof (asection *);
3519   m = bfd_zalloc (abfd, amt);
3520   if (m == NULL)
3521     return NULL;
3522   m->next = NULL;
3523   m->p_type = PT_LOAD;
3524   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3525     m->sections[i - from] = *hdrpp;
3526   m->count = to - from;
3527
3528   if (from == 0 && phdr)
3529     {
3530       /* Include the headers in the first PT_LOAD segment.  */
3531       m->includes_filehdr = 1;
3532       m->includes_phdrs = 1;
3533     }
3534
3535   return m;
3536 }
3537
3538 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
3539    on failure.  */
3540
3541 struct elf_segment_map *
3542 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3543 {
3544   struct elf_segment_map *m;
3545
3546   m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3547   if (m == NULL)
3548     return NULL;
3549   m->next = NULL;
3550   m->p_type = PT_DYNAMIC;
3551   m->count = 1;
3552   m->sections[0] = dynsec;
3553
3554   return m;
3555 }
3556
3557 /* Possibly add or remove segments from the segment map.  */
3558
3559 static bfd_boolean
3560 elf_modify_segment_map (bfd *abfd,
3561                         struct bfd_link_info *info,
3562                         bfd_boolean remove_empty_load)
3563 {
3564   struct elf_segment_map **m;
3565   const struct elf_backend_data *bed;
3566
3567   /* The placement algorithm assumes that non allocated sections are
3568      not in PT_LOAD segments.  We ensure this here by removing such
3569      sections from the segment map.  We also remove excluded
3570      sections.  Finally, any PT_LOAD segment without sections is
3571      removed.  */
3572   m = &elf_tdata (abfd)->segment_map;
3573   while (*m)
3574     {
3575       unsigned int i, new_count;
3576
3577       for (new_count = 0, i = 0; i < (*m)->count; i++)
3578         {
3579           if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3580               && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3581                   || (*m)->p_type != PT_LOAD))
3582             {
3583               (*m)->sections[new_count] = (*m)->sections[i];
3584               new_count++;
3585             }
3586         }
3587       (*m)->count = new_count;
3588
3589       if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
3590         *m = (*m)->next;
3591       else
3592         m = &(*m)->next;
3593     }
3594
3595   bed = get_elf_backend_data (abfd);
3596   if (bed->elf_backend_modify_segment_map != NULL)
3597     {
3598       if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3599         return FALSE;
3600     }
3601
3602   return TRUE;
3603 }
3604
3605 /* Set up a mapping from BFD sections to program segments.  */
3606
3607 bfd_boolean
3608 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3609 {
3610   unsigned int count;
3611   struct elf_segment_map *m;
3612   asection **sections = NULL;
3613   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3614   bfd_boolean no_user_phdrs;
3615
3616   no_user_phdrs = elf_tdata (abfd)->segment_map == NULL;
3617   if (no_user_phdrs && bfd_count_sections (abfd) != 0)
3618     {
3619       asection *s;
3620       unsigned int i;
3621       struct elf_segment_map *mfirst;
3622       struct elf_segment_map **pm;
3623       asection *last_hdr;
3624       bfd_vma last_size;
3625       unsigned int phdr_index;
3626       bfd_vma maxpagesize;
3627       asection **hdrpp;
3628       bfd_boolean phdr_in_segment = TRUE;
3629       bfd_boolean writable;
3630       int tls_count = 0;
3631       asection *first_tls = NULL;
3632       asection *dynsec, *eh_frame_hdr;
3633       bfd_size_type amt;
3634
3635       /* Select the allocated sections, and sort them.  */
3636
3637       sections = bfd_malloc2 (bfd_count_sections (abfd), sizeof (asection *));
3638       if (sections == NULL)
3639         goto error_return;
3640
3641       i = 0;
3642       for (s = abfd->sections; s != NULL; s = s->next)
3643         {
3644           if ((s->flags & SEC_ALLOC) != 0)
3645             {
3646               sections[i] = s;
3647               ++i;
3648             }
3649         }
3650       BFD_ASSERT (i <= bfd_count_sections (abfd));
3651       count = i;
3652
3653       qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3654
3655       /* Build the mapping.  */
3656
3657       mfirst = NULL;
3658       pm = &mfirst;
3659
3660       /* If we have a .interp section, then create a PT_PHDR segment for
3661          the program headers and a PT_INTERP segment for the .interp
3662          section.  */
3663       s = bfd_get_section_by_name (abfd, ".interp");
3664       if (s != NULL && (s->flags & SEC_LOAD) != 0)
3665         {
3666           amt = sizeof (struct elf_segment_map);
3667           m = bfd_zalloc (abfd, amt);
3668           if (m == NULL)
3669             goto error_return;
3670           m->next = NULL;
3671           m->p_type = PT_PHDR;
3672           /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3673           m->p_flags = PF_R | PF_X;
3674           m->p_flags_valid = 1;
3675           m->includes_phdrs = 1;
3676
3677           *pm = m;
3678           pm = &m->next;
3679
3680           amt = sizeof (struct elf_segment_map);
3681           m = bfd_zalloc (abfd, amt);
3682           if (m == NULL)
3683             goto error_return;
3684           m->next = NULL;
3685           m->p_type = PT_INTERP;
3686           m->count = 1;
3687           m->sections[0] = s;
3688
3689           *pm = m;
3690           pm = &m->next;
3691         }
3692
3693       /* Look through the sections.  We put sections in the same program
3694          segment when the start of the second section can be placed within
3695          a few bytes of the end of the first section.  */
3696       last_hdr = NULL;
3697       last_size = 0;
3698       phdr_index = 0;
3699       maxpagesize = bed->maxpagesize;
3700       writable = FALSE;
3701       dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3702       if (dynsec != NULL
3703           && (dynsec->flags & SEC_LOAD) == 0)
3704         dynsec = NULL;
3705
3706       /* Deal with -Ttext or something similar such that the first section
3707          is not adjacent to the program headers.  This is an
3708          approximation, since at this point we don't know exactly how many
3709          program headers we will need.  */
3710       if (count > 0)
3711         {
3712           bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3713
3714           if (phdr_size == (bfd_size_type) -1)
3715             phdr_size = get_program_header_size (abfd, info);
3716           if ((abfd->flags & D_PAGED) == 0
3717               || sections[0]->lma < phdr_size
3718               || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3719             phdr_in_segment = FALSE;
3720         }
3721
3722       for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3723         {
3724           asection *hdr;
3725           bfd_boolean new_segment;
3726
3727           hdr = *hdrpp;
3728
3729           /* See if this section and the last one will fit in the same
3730              segment.  */
3731
3732           if (last_hdr == NULL)
3733             {
3734               /* If we don't have a segment yet, then we don't need a new
3735                  one (we build the last one after this loop).  */
3736               new_segment = FALSE;
3737             }
3738           else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3739             {
3740               /* If this section has a different relation between the
3741                  virtual address and the load address, then we need a new
3742                  segment.  */
3743               new_segment = TRUE;
3744             }
3745           /* In the next test we have to be careful when last_hdr->lma is close
3746              to the end of the address space.  If the aligned address wraps
3747              around to the start of the address space, then there are no more
3748              pages left in memory and it is OK to assume that the current
3749              section can be included in the current segment.  */
3750           else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3751                     > last_hdr->lma)
3752                    && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3753                        <= hdr->lma))
3754             {
3755               /* If putting this section in this segment would force us to
3756                  skip a page in the segment, then we need a new segment.  */
3757               new_segment = TRUE;
3758             }
3759           else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3760                    && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3761             {
3762               /* We don't want to put a loadable section after a
3763                  nonloadable section in the same segment.
3764                  Consider .tbss sections as loadable for this purpose.  */
3765               new_segment = TRUE;
3766             }
3767           else if ((abfd->flags & D_PAGED) == 0)
3768             {
3769               /* If the file is not demand paged, which means that we
3770                  don't require the sections to be correctly aligned in the
3771                  file, then there is no other reason for a new segment.  */
3772               new_segment = FALSE;
3773             }
3774           else if (! writable
3775                    && (hdr->flags & SEC_READONLY) == 0
3776                    && (((last_hdr->lma + last_size - 1)
3777                         & ~(maxpagesize - 1))
3778                        != (hdr->lma & ~(maxpagesize - 1))))
3779             {
3780               /* We don't want to put a writable section in a read only
3781                  segment, unless they are on the same page in memory
3782                  anyhow.  We already know that the last section does not
3783                  bring us past the current section on the page, so the
3784                  only case in which the new section is not on the same
3785                  page as the previous section is when the previous section
3786                  ends precisely on a page boundary.  */
3787               new_segment = TRUE;
3788             }
3789           else
3790             {
3791               /* Otherwise, we can use the same segment.  */
3792               new_segment = FALSE;
3793             }
3794
3795           /* Allow interested parties a chance to override our decision.  */
3796           if (last_hdr != NULL
3797               && info != NULL
3798               && info->callbacks->override_segment_assignment != NULL)
3799             new_segment
3800               = info->callbacks->override_segment_assignment (info, abfd, hdr,
3801                                                               last_hdr,
3802                                                               new_segment);
3803
3804           if (! new_segment)
3805             {
3806               if ((hdr->flags & SEC_READONLY) == 0)
3807                 writable = TRUE;
3808               last_hdr = hdr;
3809               /* .tbss sections effectively have zero size.  */
3810               if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3811                   != SEC_THREAD_LOCAL)
3812                 last_size = hdr->size;
3813               else
3814                 last_size = 0;
3815               continue;
3816             }
3817
3818           /* We need a new program segment.  We must create a new program
3819              header holding all the sections from phdr_index until hdr.  */
3820
3821           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3822           if (m == NULL)
3823             goto error_return;
3824
3825           *pm = m;
3826           pm = &m->next;
3827
3828           if ((hdr->flags & SEC_READONLY) == 0)
3829             writable = TRUE;
3830           else
3831             writable = FALSE;
3832
3833           last_hdr = hdr;
3834           /* .tbss sections effectively have zero size.  */
3835           if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3836             last_size = hdr->size;
3837           else
3838             last_size = 0;
3839           phdr_index = i;
3840           phdr_in_segment = FALSE;
3841         }
3842
3843       /* Create a final PT_LOAD program segment.  */
3844       if (last_hdr != NULL)
3845         {
3846           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3847           if (m == NULL)
3848             goto error_return;
3849
3850           *pm = m;
3851           pm = &m->next;
3852         }
3853
3854       /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
3855       if (dynsec != NULL)
3856         {
3857           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3858           if (m == NULL)
3859             goto error_return;
3860           *pm = m;
3861           pm = &m->next;
3862         }
3863
3864       /* For each batch of consecutive loadable .note sections,
3865          add a PT_NOTE segment.  We don't use bfd_get_section_by_name,
3866          because if we link together nonloadable .note sections and
3867          loadable .note sections, we will generate two .note sections
3868          in the output file.  FIXME: Using names for section types is
3869          bogus anyhow.  */
3870       for (s = abfd->sections; s != NULL; s = s->next)
3871         {
3872           if ((s->flags & SEC_LOAD) != 0
3873               && CONST_STRNEQ (s->name, ".note"))
3874             {
3875               asection *s2;
3876               unsigned count = 1;
3877               amt = sizeof (struct elf_segment_map);
3878               if (s->alignment_power == 2)
3879                 for (s2 = s; s2->next != NULL; s2 = s2->next)
3880                   {
3881                     if (s2->next->alignment_power == 2
3882                         && (s2->next->flags & SEC_LOAD) != 0
3883                         && CONST_STRNEQ (s2->next->name, ".note")
3884                         && align_power (s2->vma + s2->size, 2)
3885                            == s2->next->vma)
3886                       count++;
3887                     else
3888                       break;
3889                   }
3890               amt += (count - 1) * sizeof (asection *);
3891               m = bfd_zalloc (abfd, amt);
3892               if (m == NULL)
3893                 goto error_return;
3894               m->next = NULL;
3895               m->p_type = PT_NOTE;
3896               m->count = count;
3897               while (count > 1)
3898                 {
3899                   m->sections[m->count - count--] = s;
3900                   BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
3901                   s = s->next;
3902                 }
3903               m->sections[m->count - 1] = s;
3904               BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
3905               *pm = m;
3906               pm = &m->next;
3907             }
3908           if (s->flags & SEC_THREAD_LOCAL)
3909             {
3910               if (! tls_count)
3911                 first_tls = s;
3912               tls_count++;
3913             }
3914         }
3915
3916       /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
3917       if (tls_count > 0)
3918         {
3919           int i;
3920
3921           amt = sizeof (struct elf_segment_map);
3922           amt += (tls_count - 1) * sizeof (asection *);
3923           m = bfd_zalloc (abfd, amt);
3924           if (m == NULL)
3925             goto error_return;
3926           m->next = NULL;
3927           m->p_type = PT_TLS;
3928           m->count = tls_count;
3929           /* Mandated PF_R.  */
3930           m->p_flags = PF_R;
3931           m->p_flags_valid = 1;
3932           for (i = 0; i < tls_count; ++i)
3933             {
3934               BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3935               m->sections[i] = first_tls;
3936               first_tls = first_tls->next;
3937             }
3938
3939           *pm = m;
3940           pm = &m->next;
3941         }
3942
3943       /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3944          segment.  */
3945       eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3946       if (eh_frame_hdr != NULL
3947           && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3948         {
3949           amt = sizeof (struct elf_segment_map);
3950           m = bfd_zalloc (abfd, amt);
3951           if (m == NULL)
3952             goto error_return;
3953           m->next = NULL;
3954           m->p_type = PT_GNU_EH_FRAME;
3955           m->count = 1;
3956           m->sections[0] = eh_frame_hdr->output_section;
3957
3958           *pm = m;
3959           pm = &m->next;
3960         }
3961
3962       if (elf_tdata (abfd)->stack_flags)
3963         {
3964           amt = sizeof (struct elf_segment_map);
3965           m = bfd_zalloc (abfd, amt);
3966           if (m == NULL)
3967             goto error_return;
3968           m->next = NULL;
3969           m->p_type = PT_GNU_STACK;
3970           m->p_flags = elf_tdata (abfd)->stack_flags;
3971           m->p_flags_valid = 1;
3972
3973           *pm = m;
3974           pm = &m->next;
3975         }
3976
3977       if (info != NULL && info->relro)
3978         {
3979           for (m = mfirst; m != NULL; m = m->next)
3980             {
3981               if (m->p_type == PT_LOAD)
3982                 {
3983                   asection *last = m->sections[m->count - 1];
3984                   bfd_vma vaddr = m->sections[0]->vma;
3985                   bfd_vma filesz = last->vma - vaddr + last->size;
3986
3987                   if (vaddr < info->relro_end
3988                       && vaddr >= info->relro_start
3989                       && (vaddr + filesz) >= info->relro_end)
3990                     break;
3991                 }
3992               }
3993
3994           /* Make a PT_GNU_RELRO segment only when it isn't empty.  */
3995           if (m != NULL)
3996             {
3997               amt = sizeof (struct elf_segment_map);
3998               m = bfd_zalloc (abfd, amt);
3999               if (m == NULL)
4000                 goto error_return;
4001               m->next = NULL;
4002               m->p_type = PT_GNU_RELRO;
4003               m->p_flags = PF_R;
4004               m->p_flags_valid = 1;
4005
4006               *pm = m;
4007               pm = &m->next;
4008             }
4009         }
4010
4011       free (sections);
4012       elf_tdata (abfd)->segment_map = mfirst;
4013     }
4014
4015   if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
4016     return FALSE;
4017
4018   for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4019     ++count;
4020   elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr;
4021
4022   return TRUE;
4023
4024  error_return:
4025   if (sections != NULL)
4026     free (sections);
4027   return FALSE;
4028 }
4029
4030 /* Sort sections by address.  */
4031
4032 static int
4033 elf_sort_sections (const void *arg1, const void *arg2)
4034 {
4035   const asection *sec1 = *(const asection **) arg1;
4036   const asection *sec2 = *(const asection **) arg2;
4037   bfd_size_type size1, size2;
4038
4039   /* Sort by LMA first, since this is the address used to
4040      place the section into a segment.  */
4041   if (sec1->lma < sec2->lma)
4042     return -1;
4043   else if (sec1->lma > sec2->lma)
4044     return 1;
4045
4046   /* Then sort by VMA.  Normally the LMA and the VMA will be
4047      the same, and this will do nothing.  */
4048   if (sec1->vma < sec2->vma)
4049     return -1;
4050   else if (sec1->vma > sec2->vma)
4051     return 1;
4052
4053   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
4054
4055 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4056
4057   if (TOEND (sec1))
4058     {
4059       if (TOEND (sec2))
4060         {
4061           /* If the indicies are the same, do not return 0
4062              here, but continue to try the next comparison.  */
4063           if (sec1->target_index - sec2->target_index != 0)
4064             return sec1->target_index - sec2->target_index;
4065         }
4066       else
4067         return 1;
4068     }
4069   else if (TOEND (sec2))
4070     return -1;
4071
4072 #undef TOEND
4073
4074   /* Sort by size, to put zero sized sections
4075      before others at the same address.  */
4076
4077   size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4078   size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4079
4080   if (size1 < size2)
4081     return -1;
4082   if (size1 > size2)
4083     return 1;
4084
4085   return sec1->target_index - sec2->target_index;
4086 }
4087
4088 /* Ian Lance Taylor writes:
4089
4090    We shouldn't be using % with a negative signed number.  That's just
4091    not good.  We have to make sure either that the number is not
4092    negative, or that the number has an unsigned type.  When the types
4093    are all the same size they wind up as unsigned.  When file_ptr is a
4094    larger signed type, the arithmetic winds up as signed long long,
4095    which is wrong.
4096
4097    What we're trying to say here is something like ``increase OFF by
4098    the least amount that will cause it to be equal to the VMA modulo
4099    the page size.''  */
4100 /* In other words, something like:
4101
4102    vma_offset = m->sections[0]->vma % bed->maxpagesize;
4103    off_offset = off % bed->maxpagesize;
4104    if (vma_offset < off_offset)
4105      adjustment = vma_offset + bed->maxpagesize - off_offset;
4106    else
4107      adjustment = vma_offset - off_offset;
4108
4109    which can can be collapsed into the expression below.  */
4110
4111 static file_ptr
4112 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4113 {
4114   return ((vma - off) % maxpagesize);
4115 }
4116
4117 static void
4118 print_segment_map (const struct elf_segment_map *m)
4119 {
4120   unsigned int j;
4121   const char *pt = get_segment_type (m->p_type);
4122   char buf[32];
4123
4124   if (pt == NULL)
4125     {
4126       if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4127         sprintf (buf, "LOPROC+%7.7x",
4128                  (unsigned int) (m->p_type - PT_LOPROC));
4129       else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4130         sprintf (buf, "LOOS+%7.7x",
4131                  (unsigned int) (m->p_type - PT_LOOS));
4132       else
4133         snprintf (buf, sizeof (buf), "%8.8x",
4134                   (unsigned int) m->p_type);
4135       pt = buf;
4136     }
4137   fprintf (stderr, "%s:", pt);
4138   for (j = 0; j < m->count; j++)
4139     fprintf (stderr, " %s", m->sections [j]->name);
4140   putc ('\n',stderr);
4141 }
4142
4143 /* Assign file positions to the sections based on the mapping from
4144    sections to segments.  This function also sets up some fields in
4145    the file header.  */
4146
4147 static bfd_boolean
4148 assign_file_positions_for_load_sections (bfd *abfd,
4149                                          struct bfd_link_info *link_info)
4150 {
4151   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4152   struct elf_segment_map *m;
4153   Elf_Internal_Phdr *phdrs;
4154   Elf_Internal_Phdr *p;
4155   file_ptr off;
4156   bfd_size_type maxpagesize;
4157   unsigned int alloc;
4158   unsigned int i, j;
4159
4160   if (link_info == NULL
4161       && !_bfd_elf_map_sections_to_segments (abfd, link_info))
4162     return FALSE;
4163
4164   alloc = 0;
4165   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4166     ++alloc;
4167
4168   elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4169   elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4170   elf_elfheader (abfd)->e_phnum = alloc;
4171
4172   if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1)
4173     elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr;
4174   else
4175     BFD_ASSERT (elf_tdata (abfd)->program_header_size
4176                 >= alloc * bed->s->sizeof_phdr);
4177
4178   if (alloc == 0)
4179     {
4180       elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4181       return TRUE;
4182     }
4183
4184   phdrs = bfd_alloc2 (abfd, alloc, sizeof (Elf_Internal_Phdr));
4185   elf_tdata (abfd)->phdr = phdrs;
4186   if (phdrs == NULL)
4187     return FALSE;
4188
4189   maxpagesize = 1;
4190   if ((abfd->flags & D_PAGED) != 0)
4191     maxpagesize = bed->maxpagesize;
4192
4193   off = bed->s->sizeof_ehdr;
4194   off += alloc * bed->s->sizeof_phdr;
4195
4196   for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0;
4197        m != NULL;
4198        m = m->next, p++, j++)
4199     {
4200       asection **secpp;
4201       bfd_vma off_adjust;
4202       bfd_boolean no_contents;
4203
4204       /* If elf_segment_map is not from map_sections_to_segments, the
4205          sections may not be correctly ordered.  NOTE: sorting should
4206          not be done to the PT_NOTE section of a corefile, which may
4207          contain several pseudo-sections artificially created by bfd.
4208          Sorting these pseudo-sections breaks things badly.  */
4209       if (m->count > 1
4210           && !(elf_elfheader (abfd)->e_type == ET_CORE
4211                && m->p_type == PT_NOTE))
4212         qsort (m->sections, (size_t) m->count, sizeof (asection *),
4213                elf_sort_sections);
4214
4215       /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4216          number of sections with contents contributing to both p_filesz
4217          and p_memsz, followed by a number of sections with no contents
4218          that just contribute to p_memsz.  In this loop, OFF tracks next
4219          available file offset for PT_LOAD and PT_NOTE segments.  */
4220       p->p_type = m->p_type;
4221       p->p_flags = m->p_flags;
4222
4223       if (m->count == 0)
4224         p->p_vaddr = 0;
4225       else
4226         p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
4227
4228       if (m->p_paddr_valid)
4229         p->p_paddr = m->p_paddr;
4230       else if (m->count == 0)
4231         p->p_paddr = 0;
4232       else
4233         p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
4234
4235       if (p->p_type == PT_LOAD
4236           && (abfd->flags & D_PAGED) != 0)
4237         {
4238           /* p_align in demand paged PT_LOAD segments effectively stores
4239              the maximum page size.  When copying an executable with
4240              objcopy, we set m->p_align from the input file.  Use this
4241              value for maxpagesize rather than bed->maxpagesize, which
4242              may be different.  Note that we use maxpagesize for PT_TLS
4243              segment alignment later in this function, so we are relying
4244              on at least one PT_LOAD segment appearing before a PT_TLS
4245              segment.  */
4246           if (m->p_align_valid)
4247             maxpagesize = m->p_align;
4248
4249           p->p_align = maxpagesize;
4250         }
4251       else if (m->p_align_valid)
4252         p->p_align = m->p_align;
4253       else if (m->count == 0)
4254         p->p_align = 1 << bed->s->log_file_align;
4255       else
4256         p->p_align = 0;
4257
4258       no_contents = FALSE;
4259       off_adjust = 0;
4260       if (p->p_type == PT_LOAD
4261           && m->count > 0)
4262         {
4263           bfd_size_type align;
4264           unsigned int align_power = 0;
4265
4266           if (m->p_align_valid)
4267             align = p->p_align;
4268           else
4269             {
4270               for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4271                 {
4272                   unsigned int secalign;
4273
4274                   secalign = bfd_get_section_alignment (abfd, *secpp);
4275                   if (secalign > align_power)
4276                     align_power = secalign;
4277                 }
4278               align = (bfd_size_type) 1 << align_power;
4279               if (align < maxpagesize)
4280                 align = maxpagesize;
4281             }
4282
4283           for (i = 0; i < m->count; i++)
4284             if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4285               /* If we aren't making room for this section, then
4286                  it must be SHT_NOBITS regardless of what we've
4287                  set via struct bfd_elf_special_section.  */
4288               elf_section_type (m->sections[i]) = SHT_NOBITS;
4289
4290           /* Find out whether this segment contains any loadable
4291              sections.  */
4292           no_contents = TRUE;
4293           for (i = 0; i < m->count; i++)
4294             if (elf_section_type (m->sections[i]) != SHT_NOBITS)
4295               {
4296                 no_contents = FALSE;
4297                 break;
4298               }
4299
4300           off_adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4301           off += off_adjust;
4302           if (no_contents)
4303             {
4304               /* We shouldn't need to align the segment on disk since
4305                  the segment doesn't need file space, but the gABI
4306                  arguably requires the alignment and glibc ld.so
4307                  checks it.  So to comply with the alignment
4308                  requirement but not waste file space, we adjust
4309                  p_offset for just this segment.  (OFF_ADJUST is
4310                  subtracted from OFF later.)  This may put p_offset
4311                  past the end of file, but that shouldn't matter.  */
4312             }
4313           else
4314             off_adjust = 0;
4315         }
4316       /* Make sure the .dynamic section is the first section in the
4317          PT_DYNAMIC segment.  */
4318       else if (p->p_type == PT_DYNAMIC
4319                && m->count > 1
4320                && strcmp (m->sections[0]->name, ".dynamic") != 0)
4321         {
4322           _bfd_error_handler
4323             (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4324              abfd);
4325           bfd_set_error (bfd_error_bad_value);
4326           return FALSE;
4327         }
4328       /* Set the note section type to SHT_NOTE.  */
4329       else if (p->p_type == PT_NOTE)
4330         for (i = 0; i < m->count; i++)
4331           elf_section_type (m->sections[i]) = SHT_NOTE;
4332
4333       p->p_offset = 0;
4334       p->p_filesz = 0;
4335       p->p_memsz = 0;
4336
4337       if (m->includes_filehdr)
4338         {
4339           if (!m->p_flags_valid)
4340             p->p_flags |= PF_R;
4341           p->p_filesz = bed->s->sizeof_ehdr;
4342           p->p_memsz = bed->s->sizeof_ehdr;
4343           if (m->count > 0)
4344             {
4345               BFD_ASSERT (p->p_type == PT_LOAD);
4346
4347               if (p->p_vaddr < (bfd_vma) off)
4348                 {
4349                   (*_bfd_error_handler)
4350                     (_("%B: Not enough room for program headers, try linking with -N"),
4351                      abfd);
4352                   bfd_set_error (bfd_error_bad_value);
4353                   return FALSE;
4354                 }
4355
4356               p->p_vaddr -= off;
4357               if (!m->p_paddr_valid)
4358                 p->p_paddr -= off;
4359             }
4360         }
4361
4362       if (m->includes_phdrs)
4363         {
4364           if (!m->p_flags_valid)
4365             p->p_flags |= PF_R;
4366
4367           if (!m->includes_filehdr)
4368             {
4369               p->p_offset = bed->s->sizeof_ehdr;
4370
4371               if (m->count > 0)
4372                 {
4373                   BFD_ASSERT (p->p_type == PT_LOAD);
4374                   p->p_vaddr -= off - p->p_offset;
4375                   if (!m->p_paddr_valid)
4376                     p->p_paddr -= off - p->p_offset;
4377                 }
4378             }
4379
4380           p->p_filesz += alloc * bed->s->sizeof_phdr;
4381           p->p_memsz += alloc * bed->s->sizeof_phdr;
4382         }
4383
4384       if (p->p_type == PT_LOAD
4385           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4386         {
4387           if (!m->includes_filehdr && !m->includes_phdrs)
4388             p->p_offset = off;
4389           else
4390             {
4391               file_ptr adjust;
4392
4393               adjust = off - (p->p_offset + p->p_filesz);
4394               if (!no_contents)
4395                 p->p_filesz += adjust;
4396               p->p_memsz += adjust;
4397             }
4398         }
4399
4400       /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4401          maps.  Set filepos for sections in PT_LOAD segments, and in
4402          core files, for sections in PT_NOTE segments.
4403          assign_file_positions_for_non_load_sections will set filepos
4404          for other sections and update p_filesz for other segments.  */
4405       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4406         {
4407           asection *sec;
4408           bfd_size_type align;
4409           Elf_Internal_Shdr *this_hdr;
4410
4411           sec = *secpp;
4412           this_hdr = &elf_section_data (sec)->this_hdr;
4413           align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
4414
4415           if ((p->p_type == PT_LOAD
4416                || p->p_type == PT_TLS)
4417               && (this_hdr->sh_type != SHT_NOBITS
4418                   || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4419                       && ((this_hdr->sh_flags & SHF_TLS) == 0
4420                           || p->p_type == PT_TLS))))
4421             {
4422               bfd_signed_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
4423
4424               if (adjust < 0)
4425                 {
4426                   (*_bfd_error_handler)
4427                     (_("%B: section %A vma 0x%lx overlaps previous sections"),
4428                      abfd, sec, (unsigned long) sec->vma);
4429                   adjust = 0;
4430                 }
4431               p->p_memsz += adjust;
4432
4433               if (this_hdr->sh_type != SHT_NOBITS)
4434                 {
4435                   off += adjust;
4436                   p->p_filesz += adjust;
4437                 }
4438             }
4439
4440           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4441             {
4442               /* The section at i == 0 is the one that actually contains
4443                  everything.  */
4444               if (i == 0)
4445                 {
4446                   this_hdr->sh_offset = sec->filepos = off;
4447                   off += this_hdr->sh_size;
4448                   p->p_filesz = this_hdr->sh_size;
4449                   p->p_memsz = 0;
4450                   p->p_align = 1;
4451                 }
4452               else
4453                 {
4454                   /* The rest are fake sections that shouldn't be written.  */
4455                   sec->filepos = 0;
4456                   sec->size = 0;
4457                   sec->flags = 0;
4458                   continue;
4459                 }
4460             }
4461           else
4462             {
4463               if (p->p_type == PT_LOAD)
4464                 {
4465                   this_hdr->sh_offset = sec->filepos = off;
4466                   if (this_hdr->sh_type != SHT_NOBITS)
4467                     off += this_hdr->sh_size;
4468                 }
4469
4470               if (this_hdr->sh_type != SHT_NOBITS)
4471                 {
4472                   p->p_filesz += this_hdr->sh_size;
4473                   /* A load section without SHF_ALLOC is something like
4474                      a note section in a PT_NOTE segment.  These take
4475                      file space but are not loaded into memory.  */
4476                   if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4477                     p->p_memsz += this_hdr->sh_size;
4478                 }
4479               else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4480                 {
4481                   if (p->p_type == PT_TLS)
4482                     p->p_memsz += this_hdr->sh_size;
4483
4484                   /* .tbss is special.  It doesn't contribute to p_memsz of
4485                      normal segments.  */
4486                   else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4487                     p->p_memsz += this_hdr->sh_size;
4488                 }
4489
4490               if (align > p->p_align
4491                   && !m->p_align_valid
4492                   && (p->p_type != PT_LOAD
4493                       || (abfd->flags & D_PAGED) == 0))
4494                 p->p_align = align;
4495             }
4496
4497           if (!m->p_flags_valid)
4498             {
4499               p->p_flags |= PF_R;
4500               if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4501                 p->p_flags |= PF_X;
4502               if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4503                 p->p_flags |= PF_W;
4504             }
4505         }
4506       off -= off_adjust;
4507
4508       /* Check that all sections are in a PT_LOAD segment.
4509          Don't check funky gdb generated core files.  */
4510       if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4511         for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4512           {
4513             Elf_Internal_Shdr *this_hdr;
4514             asection *sec;
4515
4516             sec = *secpp;
4517             this_hdr = &(elf_section_data(sec)->this_hdr);
4518             if (this_hdr->sh_size != 0
4519                 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, p))
4520               {
4521                 (*_bfd_error_handler)
4522                   (_("%B: section `%A' can't be allocated in segment %d"),
4523                    abfd, sec, j);
4524                 print_segment_map (m);
4525                 bfd_set_error (bfd_error_bad_value);
4526                 return FALSE;
4527               }
4528           }
4529     }
4530
4531   elf_tdata (abfd)->next_file_pos = off;
4532   return TRUE;
4533 }
4534
4535 /* Assign file positions for the other sections.  */
4536
4537 static bfd_boolean
4538 assign_file_positions_for_non_load_sections (bfd *abfd,
4539                                              struct bfd_link_info *link_info)
4540 {
4541   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4542   Elf_Internal_Shdr **i_shdrpp;
4543   Elf_Internal_Shdr **hdrpp;
4544   Elf_Internal_Phdr *phdrs;
4545   Elf_Internal_Phdr *p;
4546   struct elf_segment_map *m;
4547   bfd_vma filehdr_vaddr, filehdr_paddr;
4548   bfd_vma phdrs_vaddr, phdrs_paddr;
4549   file_ptr off;
4550   unsigned int num_sec;
4551   unsigned int i;
4552   unsigned int count;
4553
4554   i_shdrpp = elf_elfsections (abfd);
4555   num_sec = elf_numsections (abfd);
4556   off = elf_tdata (abfd)->next_file_pos;
4557   for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4558     {
4559       struct elf_obj_tdata *tdata = elf_tdata (abfd);
4560       Elf_Internal_Shdr *hdr;
4561
4562       hdr = *hdrpp;
4563       if (hdr->bfd_section != NULL
4564           && (hdr->bfd_section->filepos != 0
4565               || (hdr->sh_type == SHT_NOBITS
4566                   && hdr->contents == NULL)))
4567         BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4568       else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4569         {
4570           if (hdr->sh_size != 0)
4571             ((*_bfd_error_handler)
4572              (_("%B: warning: allocated section `%s' not in segment"),
4573               abfd,
4574               (hdr->bfd_section == NULL
4575                ? "*unknown*"
4576                : hdr->bfd_section->name)));
4577           /* We don't need to page align empty sections.  */
4578           if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4579             off += vma_page_aligned_bias (hdr->sh_addr, off,
4580                                           bed->maxpagesize);
4581           else
4582             off += vma_page_aligned_bias (hdr->sh_addr, off,
4583                                           hdr->sh_addralign);
4584           off = _bfd_elf_assign_file_position_for_section (hdr, off,
4585                                                            FALSE);
4586         }
4587       else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4588                 && hdr->bfd_section == NULL)
4589                || hdr == i_shdrpp[tdata->symtab_section]
4590                || hdr == i_shdrpp[tdata->symtab_shndx_section]
4591                || hdr == i_shdrpp[tdata->strtab_section])
4592         hdr->sh_offset = -1;
4593       else
4594         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4595     }
4596
4597   /* Now that we have set the section file positions, we can set up
4598      the file positions for the non PT_LOAD segments.  */
4599   count = 0;
4600   filehdr_vaddr = 0;
4601   filehdr_paddr = 0;
4602   phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4603   phdrs_paddr = 0;
4604   phdrs = elf_tdata (abfd)->phdr;
4605   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4606        m != NULL;
4607        m = m->next, p++)
4608     {
4609       ++count;
4610       if (p->p_type != PT_LOAD)
4611         continue;
4612
4613       if (m->includes_filehdr)
4614         {
4615           filehdr_vaddr = p->p_vaddr;
4616           filehdr_paddr = p->p_paddr;
4617         }
4618       if (m->includes_phdrs)
4619         {
4620           phdrs_vaddr = p->p_vaddr;
4621           phdrs_paddr = p->p_paddr;
4622           if (m->includes_filehdr)
4623             {
4624               phdrs_vaddr += bed->s->sizeof_ehdr;
4625               phdrs_paddr += bed->s->sizeof_ehdr;
4626             }
4627         }
4628     }
4629
4630   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4631        m != NULL;
4632        m = m->next, p++)
4633     {
4634       if (m->count != 0)
4635         {
4636           if (p->p_type != PT_LOAD
4637               && (p->p_type != PT_NOTE
4638                   || bfd_get_format (abfd) != bfd_core))
4639             {
4640               Elf_Internal_Shdr *hdr;
4641               asection *sect;
4642
4643               BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4644
4645               sect = m->sections[m->count - 1];
4646               hdr = &elf_section_data (sect)->this_hdr;
4647               p->p_filesz = sect->filepos - m->sections[0]->filepos;
4648               if (hdr->sh_type != SHT_NOBITS)
4649                 p->p_filesz += hdr->sh_size;
4650
4651               if (p->p_type == PT_GNU_RELRO)
4652                 {
4653                   /* When we get here, we are copying executable
4654                      or shared library. But we need to use the same
4655                      linker logic.  */
4656                   Elf_Internal_Phdr *lp;
4657
4658                   for (lp = phdrs; lp < phdrs + count; ++lp)
4659                     {
4660                       if (lp->p_type == PT_LOAD
4661                           && lp->p_paddr == p->p_paddr)
4662                         break;
4663                     }
4664
4665                   if (lp < phdrs + count)
4666                     {
4667                       /* We should use p_size if it is valid since it
4668                          may contain the first few bytes of the next
4669                          SEC_ALLOC section.  */
4670                       if (m->p_size_valid)
4671                         p->p_filesz = m->p_size;
4672                       else
4673                         abort ();
4674                       p->p_vaddr = lp->p_vaddr;
4675                       p->p_offset = lp->p_offset;
4676                       p->p_memsz = p->p_filesz;
4677                       p->p_align = 1;
4678                     }
4679                   else
4680                     abort ();
4681                 }
4682               else
4683                 p->p_offset = m->sections[0]->filepos;
4684             }
4685         }
4686       else
4687         {
4688           if (m->includes_filehdr)
4689             {
4690               p->p_vaddr = filehdr_vaddr;
4691               if (! m->p_paddr_valid)
4692                 p->p_paddr = filehdr_paddr;
4693             }
4694           else if (m->includes_phdrs)
4695             {
4696               p->p_vaddr = phdrs_vaddr;
4697               if (! m->p_paddr_valid)
4698                 p->p_paddr = phdrs_paddr;
4699             }
4700           else if (p->p_type == PT_GNU_RELRO)
4701             {
4702               Elf_Internal_Phdr *lp;
4703
4704               for (lp = phdrs; lp < phdrs + count; ++lp)
4705                 {
4706                   if (lp->p_type == PT_LOAD
4707                       && lp->p_vaddr <= link_info->relro_end
4708                       && lp->p_vaddr >= link_info->relro_start
4709                       && (lp->p_vaddr + lp->p_filesz
4710                           >= link_info->relro_end))
4711                     break;
4712                 }
4713
4714               if (lp < phdrs + count
4715                   && link_info->relro_end > lp->p_vaddr)
4716                 {
4717                   p->p_vaddr = lp->p_vaddr;
4718                   p->p_paddr = lp->p_paddr;
4719                   p->p_offset = lp->p_offset;
4720                   p->p_filesz = link_info->relro_end - lp->p_vaddr;
4721                   p->p_memsz = p->p_filesz;
4722                   p->p_align = 1;
4723                   p->p_flags = (lp->p_flags & ~PF_W);
4724                 }
4725               else
4726                 {
4727                   memset (p, 0, sizeof *p);
4728                   p->p_type = PT_NULL;
4729                 }
4730             }
4731         }
4732     }
4733
4734   elf_tdata (abfd)->next_file_pos = off;
4735
4736   return TRUE;
4737 }
4738
4739 /* Work out the file positions of all the sections.  This is called by
4740    _bfd_elf_compute_section_file_positions.  All the section sizes and
4741    VMAs must be known before this is called.
4742
4743    Reloc sections come in two flavours: Those processed specially as
4744    "side-channel" data attached to a section to which they apply, and
4745    those that bfd doesn't process as relocations.  The latter sort are
4746    stored in a normal bfd section by bfd_section_from_shdr.   We don't
4747    consider the former sort here, unless they form part of the loadable
4748    image.  Reloc sections not assigned here will be handled later by
4749    assign_file_positions_for_relocs.
4750
4751    We also don't set the positions of the .symtab and .strtab here.  */
4752
4753 static bfd_boolean
4754 assign_file_positions_except_relocs (bfd *abfd,
4755                                      struct bfd_link_info *link_info)
4756 {
4757   struct elf_obj_tdata *tdata = elf_tdata (abfd);
4758   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4759   file_ptr off;
4760   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4761
4762   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4763       && bfd_get_format (abfd) != bfd_core)
4764     {
4765       Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4766       unsigned int num_sec = elf_numsections (abfd);
4767       Elf_Internal_Shdr **hdrpp;
4768       unsigned int i;
4769
4770       /* Start after the ELF header.  */
4771       off = i_ehdrp->e_ehsize;
4772
4773       /* We are not creating an executable, which means that we are
4774          not creating a program header, and that the actual order of
4775          the sections in the file is unimportant.  */
4776       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4777         {
4778           Elf_Internal_Shdr *hdr;
4779
4780           hdr = *hdrpp;
4781           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4782                && hdr->bfd_section == NULL)
4783               || i == tdata->symtab_section
4784               || i == tdata->symtab_shndx_section
4785               || i == tdata->strtab_section)
4786             {
4787               hdr->sh_offset = -1;
4788             }
4789           else
4790             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4791         }
4792     }
4793   else
4794     {
4795       unsigned int alloc;
4796
4797       /* Assign file positions for the loaded sections based on the
4798          assignment of sections to segments.  */
4799       if (!assign_file_positions_for_load_sections (abfd, link_info))
4800         return FALSE;
4801
4802       /* And for non-load sections.  */
4803       if (!assign_file_positions_for_non_load_sections (abfd, link_info))
4804         return FALSE;
4805
4806       if (bed->elf_backend_modify_program_headers != NULL)
4807         {
4808           if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
4809             return FALSE;
4810         }
4811
4812       /* Write out the program headers.  */
4813       alloc = tdata->program_header_size / bed->s->sizeof_phdr;
4814       if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4815           || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
4816         return FALSE;
4817
4818       off = tdata->next_file_pos;
4819     }
4820
4821   /* Place the section headers.  */
4822   off = align_file_position (off, 1 << bed->s->log_file_align);
4823   i_ehdrp->e_shoff = off;
4824   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4825
4826   tdata->next_file_pos = off;
4827
4828   return TRUE;
4829 }
4830
4831 static bfd_boolean
4832 prep_headers (bfd *abfd)
4833 {
4834   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
4835   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4836   struct elf_strtab_hash *shstrtab;
4837   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4838
4839   i_ehdrp = elf_elfheader (abfd);
4840
4841   shstrtab = _bfd_elf_strtab_init ();
4842   if (shstrtab == NULL)
4843     return FALSE;
4844
4845   elf_shstrtab (abfd) = shstrtab;
4846
4847   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4848   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4849   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4850   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4851
4852   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4853   i_ehdrp->e_ident[EI_DATA] =
4854     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4855   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4856
4857   if ((abfd->flags & DYNAMIC) != 0)
4858     i_ehdrp->e_type = ET_DYN;
4859   else if ((abfd->flags & EXEC_P) != 0)
4860     i_ehdrp->e_type = ET_EXEC;
4861   else if (bfd_get_format (abfd) == bfd_core)
4862     i_ehdrp->e_type = ET_CORE;
4863   else
4864     i_ehdrp->e_type = ET_REL;
4865
4866   switch (bfd_get_arch (abfd))
4867     {
4868     case bfd_arch_unknown:
4869       i_ehdrp->e_machine = EM_NONE;
4870       break;
4871
4872       /* There used to be a long list of cases here, each one setting
4873          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4874          in the corresponding bfd definition.  To avoid duplication,
4875          the switch was removed.  Machines that need special handling
4876          can generally do it in elf_backend_final_write_processing(),
4877          unless they need the information earlier than the final write.
4878          Such need can generally be supplied by replacing the tests for
4879          e_machine with the conditions used to determine it.  */
4880     default:
4881       i_ehdrp->e_machine = bed->elf_machine_code;
4882     }
4883
4884   i_ehdrp->e_version = bed->s->ev_current;
4885   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4886
4887   /* No program header, for now.  */
4888   i_ehdrp->e_phoff = 0;
4889   i_ehdrp->e_phentsize = 0;
4890   i_ehdrp->e_phnum = 0;
4891
4892   /* Each bfd section is section header entry.  */
4893   i_ehdrp->e_entry = bfd_get_start_address (abfd);
4894   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4895
4896   /* If we're building an executable, we'll need a program header table.  */
4897   if (abfd->flags & EXEC_P)
4898     /* It all happens later.  */
4899     ;
4900   else
4901     {
4902       i_ehdrp->e_phentsize = 0;
4903       i_phdrp = 0;
4904       i_ehdrp->e_phoff = 0;
4905     }
4906
4907   elf_tdata (abfd)->symtab_hdr.sh_name =
4908     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4909   elf_tdata (abfd)->strtab_hdr.sh_name =
4910     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4911   elf_tdata (abfd)->shstrtab_hdr.sh_name =
4912     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4913   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4914       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4915       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4916     return FALSE;
4917
4918   return TRUE;
4919 }
4920
4921 /* Assign file positions for all the reloc sections which are not part
4922    of the loadable file image.  */
4923
4924 void
4925 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4926 {
4927   file_ptr off;
4928   unsigned int i, num_sec;
4929   Elf_Internal_Shdr **shdrpp;
4930
4931   off = elf_tdata (abfd)->next_file_pos;
4932
4933   num_sec = elf_numsections (abfd);
4934   for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4935     {
4936       Elf_Internal_Shdr *shdrp;
4937
4938       shdrp = *shdrpp;
4939       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4940           && shdrp->sh_offset == -1)
4941         off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4942     }
4943
4944   elf_tdata (abfd)->next_file_pos = off;
4945 }
4946
4947 bfd_boolean
4948 _bfd_elf_write_object_contents (bfd *abfd)
4949 {
4950   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4951   Elf_Internal_Ehdr *i_ehdrp;
4952   Elf_Internal_Shdr **i_shdrp;
4953   bfd_boolean failed;
4954   unsigned int count, num_sec;
4955
4956   if (! abfd->output_has_begun
4957       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4958     return FALSE;
4959
4960   i_shdrp = elf_elfsections (abfd);
4961   i_ehdrp = elf_elfheader (abfd);
4962
4963   failed = FALSE;
4964   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4965   if (failed)
4966     return FALSE;
4967
4968   _bfd_elf_assign_file_positions_for_relocs (abfd);
4969
4970   /* After writing the headers, we need to write the sections too...  */
4971   num_sec = elf_numsections (abfd);
4972   for (count = 1; count < num_sec; count++)
4973     {
4974       if (bed->elf_backend_section_processing)
4975         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4976       if (i_shdrp[count]->contents)
4977         {
4978           bfd_size_type amt = i_shdrp[count]->sh_size;
4979
4980           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4981               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4982             return FALSE;
4983         }
4984     }
4985
4986   /* Write out the section header names.  */
4987   if (elf_shstrtab (abfd) != NULL
4988       && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4989           || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
4990     return FALSE;
4991
4992   if (bed->elf_backend_final_write_processing)
4993     (*bed->elf_backend_final_write_processing) (abfd,
4994                                                 elf_tdata (abfd)->linker);
4995
4996   if (!bed->s->write_shdrs_and_ehdr (abfd))
4997     return FALSE;
4998
4999   /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0].  */
5000   if (elf_tdata (abfd)->after_write_object_contents)
5001     return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
5002
5003   return TRUE;
5004 }
5005
5006 bfd_boolean
5007 _bfd_elf_write_corefile_contents (bfd *abfd)
5008 {
5009   /* Hopefully this can be done just like an object file.  */
5010   return _bfd_elf_write_object_contents (abfd);
5011 }
5012
5013 /* Given a section, search the header to find them.  */
5014
5015 unsigned int
5016 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
5017 {
5018   const struct elf_backend_data *bed;
5019   unsigned int index;
5020
5021   if (elf_section_data (asect) != NULL
5022       && elf_section_data (asect)->this_idx != 0)
5023     return elf_section_data (asect)->this_idx;
5024
5025   if (bfd_is_abs_section (asect))
5026     index = SHN_ABS;
5027   else if (bfd_is_com_section (asect))
5028     index = SHN_COMMON;
5029   else if (bfd_is_und_section (asect))
5030     index = SHN_UNDEF;
5031   else
5032     index = SHN_BAD;
5033
5034   bed = get_elf_backend_data (abfd);
5035   if (bed->elf_backend_section_from_bfd_section)
5036     {
5037       int retval = index;
5038
5039       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5040         return retval;
5041     }
5042
5043   if (index == SHN_BAD)
5044     bfd_set_error (bfd_error_nonrepresentable_section);
5045
5046   return index;
5047 }
5048
5049 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5050    on error.  */
5051
5052 int
5053 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
5054 {
5055   asymbol *asym_ptr = *asym_ptr_ptr;
5056   int idx;
5057   flagword flags = asym_ptr->flags;
5058
5059   /* When gas creates relocations against local labels, it creates its
5060      own symbol for the section, but does put the symbol into the
5061      symbol chain, so udata is 0.  When the linker is generating
5062      relocatable output, this section symbol may be for one of the
5063      input sections rather than the output section.  */
5064   if (asym_ptr->udata.i == 0
5065       && (flags & BSF_SECTION_SYM)
5066       && asym_ptr->section)
5067     {
5068       asection *sec;
5069       int indx;
5070
5071       sec = asym_ptr->section;
5072       if (sec->owner != abfd && sec->output_section != NULL)
5073         sec = sec->output_section;
5074       if (sec->owner == abfd
5075           && (indx = sec->index) < elf_num_section_syms (abfd)
5076           && elf_section_syms (abfd)[indx] != NULL)
5077         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5078     }
5079
5080   idx = asym_ptr->udata.i;
5081
5082   if (idx == 0)
5083     {
5084       /* This case can occur when using --strip-symbol on a symbol
5085          which is used in a relocation entry.  */
5086       (*_bfd_error_handler)
5087         (_("%B: symbol `%s' required but not present"),
5088          abfd, bfd_asymbol_name (asym_ptr));
5089       bfd_set_error (bfd_error_no_symbols);
5090       return -1;
5091     }
5092
5093 #if DEBUG & 4
5094   {
5095     fprintf (stderr,
5096              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5097              (long) asym_ptr, asym_ptr->name, idx, flags,
5098              elf_symbol_flags (flags));
5099     fflush (stderr);
5100   }
5101 #endif
5102
5103   return idx;
5104 }
5105
5106 /* Rewrite program header information.  */
5107
5108 static bfd_boolean
5109 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5110 {
5111   Elf_Internal_Ehdr *iehdr;
5112   struct elf_segment_map *map;
5113   struct elf_segment_map *map_first;
5114   struct elf_segment_map **pointer_to_map;
5115   Elf_Internal_Phdr *segment;
5116   asection *section;
5117   unsigned int i;
5118   unsigned int num_segments;
5119   bfd_boolean phdr_included = FALSE;
5120   bfd_boolean p_paddr_valid;
5121   bfd_vma maxpagesize;
5122   struct elf_segment_map *phdr_adjust_seg = NULL;
5123   unsigned int phdr_adjust_num = 0;
5124   const struct elf_backend_data *bed;
5125
5126   bed = get_elf_backend_data (ibfd);
5127   iehdr = elf_elfheader (ibfd);
5128
5129   map_first = NULL;
5130   pointer_to_map = &map_first;
5131
5132   num_segments = elf_elfheader (ibfd)->e_phnum;
5133   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5134
5135   /* Returns the end address of the segment + 1.  */
5136 #define SEGMENT_END(segment, start)                                     \
5137   (start + (segment->p_memsz > segment->p_filesz                        \
5138             ? segment->p_memsz : segment->p_filesz))
5139
5140 #define SECTION_SIZE(section, segment)                                  \
5141   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
5142     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
5143    ? section->size : 0)
5144
5145   /* Returns TRUE if the given section is contained within
5146      the given segment.  VMA addresses are compared.  */
5147 #define IS_CONTAINED_BY_VMA(section, segment)                           \
5148   (section->vma >= segment->p_vaddr                                     \
5149    && (section->vma + SECTION_SIZE (section, segment)                   \
5150        <= (SEGMENT_END (segment, segment->p_vaddr))))
5151
5152   /* Returns TRUE if the given section is contained within
5153      the given segment.  LMA addresses are compared.  */
5154 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
5155   (section->lma >= base                                                 \
5156    && (section->lma + SECTION_SIZE (section, segment)                   \
5157        <= SEGMENT_END (segment, base)))
5158
5159   /* Handle PT_NOTE segment.  */
5160 #define IS_NOTE(p, s)                                                   \
5161   (p->p_type == PT_NOTE                                                 \
5162    && elf_section_type (s) == SHT_NOTE                                  \
5163    && (bfd_vma) s->filepos >= p->p_offset                               \
5164    && ((bfd_vma) s->filepos + s->size                                   \
5165        <= p->p_offset + p->p_filesz))
5166
5167   /* Special case: corefile "NOTE" section containing regs, prpsinfo
5168      etc.  */
5169 #define IS_COREFILE_NOTE(p, s)                                          \
5170   (IS_NOTE (p, s)                                                       \
5171    && bfd_get_format (ibfd) == bfd_core                                 \
5172    && s->vma == 0                                                       \
5173    && s->lma == 0)
5174
5175   /* The complicated case when p_vaddr is 0 is to handle the Solaris
5176      linker, which generates a PT_INTERP section with p_vaddr and
5177      p_memsz set to 0.  */
5178 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
5179   (p->p_vaddr == 0                                                      \
5180    && p->p_paddr == 0                                                   \
5181    && p->p_memsz == 0                                                   \
5182    && p->p_filesz > 0                                                   \
5183    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
5184    && s->size > 0                                                       \
5185    && (bfd_vma) s->filepos >= p->p_offset                               \
5186    && ((bfd_vma) s->filepos + s->size                                   \
5187        <= p->p_offset + p->p_filesz))
5188
5189   /* Decide if the given section should be included in the given segment.
5190      A section will be included if:
5191        1. It is within the address space of the segment -- we use the LMA
5192           if that is set for the segment and the VMA otherwise,
5193        2. It is an allocated section or a NOTE section in a PT_NOTE
5194           segment.
5195        3. There is an output section associated with it,
5196        4. The section has not already been allocated to a previous segment.
5197        5. PT_GNU_STACK segments do not include any sections.
5198        6. PT_TLS segment includes only SHF_TLS sections.
5199        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5200        8. PT_DYNAMIC should not contain empty sections at the beginning
5201           (with the possible exception of .dynamic).  */
5202 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed)              \
5203   ((((segment->p_paddr                                                  \
5204       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
5205       : IS_CONTAINED_BY_VMA (section, segment))                         \
5206      && (section->flags & SEC_ALLOC) != 0)                              \
5207     || IS_NOTE (segment, section))                                      \
5208    && segment->p_type != PT_GNU_STACK                                   \
5209    && (segment->p_type != PT_TLS                                        \
5210        || (section->flags & SEC_THREAD_LOCAL))                          \
5211    && (segment->p_type == PT_LOAD                                       \
5212        || segment->p_type == PT_TLS                                     \
5213        || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
5214    && (segment->p_type != PT_DYNAMIC                                    \
5215        || SECTION_SIZE (section, segment) > 0                           \
5216        || (segment->p_paddr                                             \
5217            ? segment->p_paddr != section->lma                           \
5218            : segment->p_vaddr != section->vma)                          \
5219        || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic")    \
5220            == 0))                                                       \
5221    && !section->segment_mark)
5222
5223 /* If the output section of a section in the input segment is NULL,
5224    it is removed from the corresponding output segment.   */
5225 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
5226   (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed)          \
5227    && section->output_section != NULL)
5228
5229   /* Returns TRUE iff seg1 starts after the end of seg2.  */
5230 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
5231   (seg1->field >= SEGMENT_END (seg2, seg2->field))
5232
5233   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5234      their VMA address ranges and their LMA address ranges overlap.
5235      It is possible to have overlapping VMA ranges without overlapping LMA
5236      ranges.  RedBoot images for example can have both .data and .bss mapped
5237      to the same VMA range, but with the .data section mapped to a different
5238      LMA.  */
5239 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
5240   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
5241         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
5242    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
5243         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5244
5245   /* Initialise the segment mark field.  */
5246   for (section = ibfd->sections; section != NULL; section = section->next)
5247     section->segment_mark = FALSE;
5248
5249   /* The Solaris linker creates program headers in which all the
5250      p_paddr fields are zero.  When we try to objcopy or strip such a
5251      file, we get confused.  Check for this case, and if we find it
5252      don't set the p_paddr_valid fields.  */
5253   p_paddr_valid = FALSE;
5254   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5255        i < num_segments;
5256        i++, segment++)
5257     if (segment->p_paddr != 0)
5258       {
5259         p_paddr_valid = TRUE;
5260         break;
5261       }
5262
5263   /* Scan through the segments specified in the program header
5264      of the input BFD.  For this first scan we look for overlaps
5265      in the loadable segments.  These can be created by weird
5266      parameters to objcopy.  Also, fix some solaris weirdness.  */
5267   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5268        i < num_segments;
5269        i++, segment++)
5270     {
5271       unsigned int j;
5272       Elf_Internal_Phdr *segment2;
5273
5274       if (segment->p_type == PT_INTERP)
5275         for (section = ibfd->sections; section; section = section->next)
5276           if (IS_SOLARIS_PT_INTERP (segment, section))
5277             {
5278               /* Mininal change so that the normal section to segment
5279                  assignment code will work.  */
5280               segment->p_vaddr = section->vma;
5281               break;
5282             }
5283
5284       if (segment->p_type != PT_LOAD)
5285         {
5286           /* Remove PT_GNU_RELRO segment.  */
5287           if (segment->p_type == PT_GNU_RELRO)
5288             segment->p_type = PT_NULL;
5289           continue;
5290         }
5291
5292       /* Determine if this segment overlaps any previous segments.  */
5293       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
5294         {
5295           bfd_signed_vma extra_length;
5296
5297           if (segment2->p_type != PT_LOAD
5298               || !SEGMENT_OVERLAPS (segment, segment2))
5299             continue;
5300
5301           /* Merge the two segments together.  */
5302           if (segment2->p_vaddr < segment->p_vaddr)
5303             {
5304               /* Extend SEGMENT2 to include SEGMENT and then delete
5305                  SEGMENT.  */
5306               extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5307                               - SEGMENT_END (segment2, segment2->p_vaddr));
5308
5309               if (extra_length > 0)
5310                 {
5311                   segment2->p_memsz += extra_length;
5312                   segment2->p_filesz += extra_length;
5313                 }
5314
5315               segment->p_type = PT_NULL;
5316
5317               /* Since we have deleted P we must restart the outer loop.  */
5318               i = 0;
5319               segment = elf_tdata (ibfd)->phdr;
5320               break;
5321             }
5322           else
5323             {
5324               /* Extend SEGMENT to include SEGMENT2 and then delete
5325                  SEGMENT2.  */
5326               extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5327                               - SEGMENT_END (segment, segment->p_vaddr));
5328
5329               if (extra_length > 0)
5330                 {
5331                   segment->p_memsz += extra_length;
5332                   segment->p_filesz += extra_length;
5333                 }
5334
5335               segment2->p_type = PT_NULL;
5336             }
5337         }
5338     }
5339
5340   /* The second scan attempts to assign sections to segments.  */
5341   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5342        i < num_segments;
5343        i++, segment++)
5344     {
5345       unsigned int section_count;
5346       asection **sections;
5347       asection *output_section;
5348       unsigned int isec;
5349       bfd_vma matching_lma;
5350       bfd_vma suggested_lma;
5351       unsigned int j;
5352       bfd_size_type amt;
5353       asection *first_section;
5354       bfd_boolean first_matching_lma;
5355       bfd_boolean first_suggested_lma;
5356
5357       if (segment->p_type == PT_NULL)
5358         continue;
5359
5360       first_section = NULL;
5361       /* Compute how many sections might be placed into this segment.  */
5362       for (section = ibfd->sections, section_count = 0;
5363            section != NULL;
5364            section = section->next)
5365         {
5366           /* Find the first section in the input segment, which may be
5367              removed from the corresponding output segment.   */
5368           if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5369             {
5370               if (first_section == NULL)
5371                 first_section = section;
5372               if (section->output_section != NULL)
5373                 ++section_count;
5374             }
5375         }
5376
5377       /* Allocate a segment map big enough to contain
5378          all of the sections we have selected.  */
5379       amt = sizeof (struct elf_segment_map);
5380       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5381       map = bfd_zalloc (obfd, amt);
5382       if (map == NULL)
5383         return FALSE;
5384
5385       /* Initialise the fields of the segment map.  Default to
5386          using the physical address of the segment in the input BFD.  */
5387       map->next = NULL;
5388       map->p_type = segment->p_type;
5389       map->p_flags = segment->p_flags;
5390       map->p_flags_valid = 1;
5391
5392       /* If the first section in the input segment is removed, there is
5393          no need to preserve segment physical address in the corresponding
5394          output segment.  */
5395       if (!first_section || first_section->output_section != NULL)
5396         {
5397           map->p_paddr = segment->p_paddr;
5398           map->p_paddr_valid = p_paddr_valid;
5399         }
5400
5401       /* Determine if this segment contains the ELF file header
5402          and if it contains the program headers themselves.  */
5403       map->includes_filehdr = (segment->p_offset == 0
5404                                && segment->p_filesz >= iehdr->e_ehsize);
5405       map->includes_phdrs = 0;
5406
5407       if (!phdr_included || segment->p_type != PT_LOAD)
5408         {
5409           map->includes_phdrs =
5410             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5411              && (segment->p_offset + segment->p_filesz
5412                  >= ((bfd_vma) iehdr->e_phoff
5413                      + iehdr->e_phnum * iehdr->e_phentsize)));
5414
5415           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5416             phdr_included = TRUE;
5417         }
5418
5419       if (section_count == 0)
5420         {
5421           /* Special segments, such as the PT_PHDR segment, may contain
5422              no sections, but ordinary, loadable segments should contain
5423              something.  They are allowed by the ELF spec however, so only
5424              a warning is produced.  */
5425           if (segment->p_type == PT_LOAD)
5426             (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5427                                      " detected, is this intentional ?\n"),
5428                                    ibfd);
5429
5430           map->count = 0;
5431           *pointer_to_map = map;
5432           pointer_to_map = &map->next;
5433
5434           continue;
5435         }
5436
5437       /* Now scan the sections in the input BFD again and attempt
5438          to add their corresponding output sections to the segment map.
5439          The problem here is how to handle an output section which has
5440          been moved (ie had its LMA changed).  There are four possibilities:
5441
5442          1. None of the sections have been moved.
5443             In this case we can continue to use the segment LMA from the
5444             input BFD.
5445
5446          2. All of the sections have been moved by the same amount.
5447             In this case we can change the segment's LMA to match the LMA
5448             of the first section.
5449
5450          3. Some of the sections have been moved, others have not.
5451             In this case those sections which have not been moved can be
5452             placed in the current segment which will have to have its size,
5453             and possibly its LMA changed, and a new segment or segments will
5454             have to be created to contain the other sections.
5455
5456          4. The sections have been moved, but not by the same amount.
5457             In this case we can change the segment's LMA to match the LMA
5458             of the first section and we will have to create a new segment
5459             or segments to contain the other sections.
5460
5461          In order to save time, we allocate an array to hold the section
5462          pointers that we are interested in.  As these sections get assigned
5463          to a segment, they are removed from this array.  */
5464
5465       sections = bfd_malloc2 (section_count, sizeof (asection *));
5466       if (sections == NULL)
5467         return FALSE;
5468
5469       /* Step One: Scan for segment vs section LMA conflicts.
5470          Also add the sections to the section array allocated above.
5471          Also add the sections to the current segment.  In the common
5472          case, where the sections have not been moved, this means that
5473          we have completely filled the segment, and there is nothing
5474          more to do.  */
5475       isec = 0;
5476       matching_lma = 0;
5477       suggested_lma = 0;
5478       first_matching_lma = TRUE;
5479       first_suggested_lma = TRUE;
5480
5481       for (section = ibfd->sections;
5482            section != NULL;
5483            section = section->next)
5484         if (section == first_section)
5485           break;
5486
5487       for (j = 0; section != NULL; section = section->next)
5488         {
5489           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5490             {
5491               output_section = section->output_section;
5492
5493               sections[j++] = section;
5494
5495               /* The Solaris native linker always sets p_paddr to 0.
5496                  We try to catch that case here, and set it to the
5497                  correct value.  Note - some backends require that
5498                  p_paddr be left as zero.  */
5499               if (!p_paddr_valid
5500                   && segment->p_vaddr != 0
5501                   && !bed->want_p_paddr_set_to_zero
5502                   && isec == 0
5503                   && output_section->lma != 0
5504                   && output_section->vma == (segment->p_vaddr
5505                                              + (map->includes_filehdr
5506                                                 ? iehdr->e_ehsize
5507                                                 : 0)
5508                                              + (map->includes_phdrs
5509                                                 ? (iehdr->e_phnum
5510                                                    * iehdr->e_phentsize)
5511                                                 : 0)))
5512                 map->p_paddr = segment->p_vaddr;
5513
5514               /* Match up the physical address of the segment with the
5515                  LMA address of the output section.  */
5516               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5517                   || IS_COREFILE_NOTE (segment, section)
5518                   || (bed->want_p_paddr_set_to_zero
5519                       && IS_CONTAINED_BY_VMA (output_section, segment)))
5520                 {
5521                   if (first_matching_lma || output_section->lma < matching_lma)
5522                     {
5523                       matching_lma = output_section->lma;
5524                       first_matching_lma = FALSE;
5525                     }
5526
5527                   /* We assume that if the section fits within the segment
5528                      then it does not overlap any other section within that
5529                      segment.  */
5530                   map->sections[isec++] = output_section;
5531                 }
5532               else if (first_suggested_lma)
5533                 {
5534                   suggested_lma = output_section->lma;
5535                   first_suggested_lma = FALSE;
5536                 }
5537
5538               if (j == section_count)
5539                 break;
5540             }
5541         }
5542
5543       BFD_ASSERT (j == section_count);
5544
5545       /* Step Two: Adjust the physical address of the current segment,
5546          if necessary.  */
5547       if (isec == section_count)
5548         {
5549           /* All of the sections fitted within the segment as currently
5550              specified.  This is the default case.  Add the segment to
5551              the list of built segments and carry on to process the next
5552              program header in the input BFD.  */
5553           map->count = section_count;
5554           *pointer_to_map = map;
5555           pointer_to_map = &map->next;
5556
5557           if (p_paddr_valid
5558               && !bed->want_p_paddr_set_to_zero
5559               && matching_lma != map->p_paddr
5560               && !map->includes_filehdr
5561               && !map->includes_phdrs)
5562             /* There is some padding before the first section in the
5563                segment.  So, we must account for that in the output
5564                segment's vma.  */
5565             map->p_vaddr_offset = matching_lma - map->p_paddr;
5566
5567           free (sections);
5568           continue;
5569         }
5570       else
5571         {
5572           if (!first_matching_lma)
5573             {
5574               /* At least one section fits inside the current segment.
5575                  Keep it, but modify its physical address to match the
5576                  LMA of the first section that fitted.  */
5577               map->p_paddr = matching_lma;
5578             }
5579           else
5580             {
5581               /* None of the sections fitted inside the current segment.
5582                  Change the current segment's physical address to match
5583                  the LMA of the first section.  */
5584               map->p_paddr = suggested_lma;
5585             }
5586
5587           /* Offset the segment physical address from the lma
5588              to allow for space taken up by elf headers.  */
5589           if (map->includes_filehdr)
5590             {
5591               if (map->p_paddr >= iehdr->e_ehsize)
5592                 map->p_paddr -= iehdr->e_ehsize;
5593               else
5594                 {
5595                   map->includes_filehdr = FALSE;
5596                   map->includes_phdrs = FALSE;
5597                 }
5598             }
5599
5600           if (map->includes_phdrs)
5601             {
5602               if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
5603                 {
5604                   map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5605
5606                   /* iehdr->e_phnum is just an estimate of the number
5607                      of program headers that we will need.  Make a note
5608                      here of the number we used and the segment we chose
5609                      to hold these headers, so that we can adjust the
5610                      offset when we know the correct value.  */
5611                   phdr_adjust_num = iehdr->e_phnum;
5612                   phdr_adjust_seg = map;
5613                 }
5614               else
5615                 map->includes_phdrs = FALSE;
5616             }
5617         }
5618
5619       /* Step Three: Loop over the sections again, this time assigning
5620          those that fit to the current segment and removing them from the
5621          sections array; but making sure not to leave large gaps.  Once all
5622          possible sections have been assigned to the current segment it is
5623          added to the list of built segments and if sections still remain
5624          to be assigned, a new segment is constructed before repeating
5625          the loop.  */
5626       isec = 0;
5627       do
5628         {
5629           map->count = 0;
5630           suggested_lma = 0;
5631           first_suggested_lma = TRUE;
5632
5633           /* Fill the current segment with sections that fit.  */
5634           for (j = 0; j < section_count; j++)
5635             {
5636               section = sections[j];
5637
5638               if (section == NULL)
5639                 continue;
5640
5641               output_section = section->output_section;
5642
5643               BFD_ASSERT (output_section != NULL);
5644
5645               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5646                   || IS_COREFILE_NOTE (segment, section))
5647                 {
5648                   if (map->count == 0)
5649                     {
5650                       /* If the first section in a segment does not start at
5651                          the beginning of the segment, then something is
5652                          wrong.  */
5653                       if (output_section->lma
5654                           != (map->p_paddr
5655                               + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5656                               + (map->includes_phdrs
5657                                  ? iehdr->e_phnum * iehdr->e_phentsize
5658                                  : 0)))
5659                         abort ();
5660                     }
5661                   else
5662                     {
5663                       asection *prev_sec;
5664
5665                       prev_sec = map->sections[map->count - 1];
5666
5667                       /* If the gap between the end of the previous section
5668                          and the start of this section is more than
5669                          maxpagesize then we need to start a new segment.  */
5670                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5671                                       maxpagesize)
5672                            < BFD_ALIGN (output_section->lma, maxpagesize))
5673                           || (prev_sec->lma + prev_sec->size
5674                               > output_section->lma))
5675                         {
5676                           if (first_suggested_lma)
5677                             {
5678                               suggested_lma = output_section->lma;
5679                               first_suggested_lma = FALSE;
5680                             }
5681
5682                           continue;
5683                         }
5684                     }
5685
5686                   map->sections[map->count++] = output_section;
5687                   ++isec;
5688                   sections[j] = NULL;
5689                   section->segment_mark = TRUE;
5690                 }
5691               else if (first_suggested_lma)
5692                 {
5693                   suggested_lma = output_section->lma;
5694                   first_suggested_lma = FALSE;
5695                 }
5696             }
5697
5698           BFD_ASSERT (map->count > 0);
5699
5700           /* Add the current segment to the list of built segments.  */
5701           *pointer_to_map = map;
5702           pointer_to_map = &map->next;
5703
5704           if (isec < section_count)
5705             {
5706               /* We still have not allocated all of the sections to
5707                  segments.  Create a new segment here, initialise it
5708                  and carry on looping.  */
5709               amt = sizeof (struct elf_segment_map);
5710               amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5711               map = bfd_alloc (obfd, amt);
5712               if (map == NULL)
5713                 {
5714                   free (sections);
5715                   return FALSE;
5716                 }
5717
5718               /* Initialise the fields of the segment map.  Set the physical
5719                  physical address to the LMA of the first section that has
5720                  not yet been assigned.  */
5721               map->next = NULL;
5722               map->p_type = segment->p_type;
5723               map->p_flags = segment->p_flags;
5724               map->p_flags_valid = 1;
5725               map->p_paddr = suggested_lma;
5726               map->p_paddr_valid = p_paddr_valid;
5727               map->includes_filehdr = 0;
5728               map->includes_phdrs = 0;
5729             }
5730         }
5731       while (isec < section_count);
5732
5733       free (sections);
5734     }
5735
5736   elf_tdata (obfd)->segment_map = map_first;
5737
5738   /* If we had to estimate the number of program headers that were
5739      going to be needed, then check our estimate now and adjust
5740      the offset if necessary.  */
5741   if (phdr_adjust_seg != NULL)
5742     {
5743       unsigned int count;
5744
5745       for (count = 0, map = map_first; map != NULL; map = map->next)
5746         count++;
5747
5748       if (count > phdr_adjust_num)
5749         phdr_adjust_seg->p_paddr
5750           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5751     }
5752
5753 #undef SEGMENT_END
5754 #undef SECTION_SIZE
5755 #undef IS_CONTAINED_BY_VMA
5756 #undef IS_CONTAINED_BY_LMA
5757 #undef IS_NOTE
5758 #undef IS_COREFILE_NOTE
5759 #undef IS_SOLARIS_PT_INTERP
5760 #undef IS_SECTION_IN_INPUT_SEGMENT
5761 #undef INCLUDE_SECTION_IN_SEGMENT
5762 #undef SEGMENT_AFTER_SEGMENT
5763 #undef SEGMENT_OVERLAPS
5764   return TRUE;
5765 }
5766
5767 /* Copy ELF program header information.  */
5768
5769 static bfd_boolean
5770 copy_elf_program_header (bfd *ibfd, bfd *obfd)
5771 {
5772   Elf_Internal_Ehdr *iehdr;
5773   struct elf_segment_map *map;
5774   struct elf_segment_map *map_first;
5775   struct elf_segment_map **pointer_to_map;
5776   Elf_Internal_Phdr *segment;
5777   unsigned int i;
5778   unsigned int num_segments;
5779   bfd_boolean phdr_included = FALSE;
5780   bfd_boolean p_paddr_valid;
5781
5782   iehdr = elf_elfheader (ibfd);
5783
5784   map_first = NULL;
5785   pointer_to_map = &map_first;
5786
5787   /* If all the segment p_paddr fields are zero, don't set
5788      map->p_paddr_valid.  */
5789   p_paddr_valid = FALSE;
5790   num_segments = elf_elfheader (ibfd)->e_phnum;
5791   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5792        i < num_segments;
5793        i++, segment++)
5794     if (segment->p_paddr != 0)
5795       {
5796         p_paddr_valid = TRUE;
5797         break;
5798       }
5799
5800   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5801        i < num_segments;
5802        i++, segment++)
5803     {
5804       asection *section;
5805       unsigned int section_count;
5806       bfd_size_type amt;
5807       Elf_Internal_Shdr *this_hdr;
5808       asection *first_section = NULL;
5809       asection *lowest_section = NULL;
5810
5811       /* Compute how many sections are in this segment.  */
5812       for (section = ibfd->sections, section_count = 0;
5813            section != NULL;
5814            section = section->next)
5815         {
5816           this_hdr = &(elf_section_data(section)->this_hdr);
5817           if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5818             {
5819               if (!first_section)
5820                 first_section = lowest_section = section;
5821               if (section->lma < lowest_section->lma)
5822                 lowest_section = section;
5823               section_count++;
5824             }
5825         }
5826
5827       /* Allocate a segment map big enough to contain
5828          all of the sections we have selected.  */
5829       amt = sizeof (struct elf_segment_map);
5830       if (section_count != 0)
5831         amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5832       map = bfd_zalloc (obfd, amt);
5833       if (map == NULL)
5834         return FALSE;
5835
5836       /* Initialize the fields of the output segment map with the
5837          input segment.  */
5838       map->next = NULL;
5839       map->p_type = segment->p_type;
5840       map->p_flags = segment->p_flags;
5841       map->p_flags_valid = 1;
5842       map->p_paddr = segment->p_paddr;
5843       map->p_paddr_valid = p_paddr_valid;
5844       map->p_align = segment->p_align;
5845       map->p_align_valid = 1;
5846       map->p_vaddr_offset = 0;
5847
5848       if (map->p_type == PT_GNU_RELRO
5849           && segment->p_filesz == segment->p_memsz)
5850         {
5851           /* The PT_GNU_RELRO segment may contain the first a few
5852              bytes in the .got.plt section even if the whole .got.plt
5853              section isn't in the PT_GNU_RELRO segment.  We won't
5854              change the size of the PT_GNU_RELRO segment.  */
5855           map->p_size = segment->p_filesz;
5856           map->p_size_valid = 1;
5857         }
5858
5859       /* Determine if this segment contains the ELF file header
5860          and if it contains the program headers themselves.  */
5861       map->includes_filehdr = (segment->p_offset == 0
5862                                && segment->p_filesz >= iehdr->e_ehsize);
5863
5864       map->includes_phdrs = 0;
5865       if (! phdr_included || segment->p_type != PT_LOAD)
5866         {
5867           map->includes_phdrs =
5868             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5869              && (segment->p_offset + segment->p_filesz
5870                  >= ((bfd_vma) iehdr->e_phoff
5871                      + iehdr->e_phnum * iehdr->e_phentsize)));
5872
5873           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5874             phdr_included = TRUE;
5875         }
5876
5877       if (!map->includes_phdrs
5878           && !map->includes_filehdr
5879           && map->p_paddr_valid)
5880         /* There is some other padding before the first section.  */
5881         map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
5882                                - segment->p_paddr);
5883
5884       if (section_count != 0)
5885         {
5886           unsigned int isec = 0;
5887
5888           for (section = first_section;
5889                section != NULL;
5890                section = section->next)
5891             {
5892               this_hdr = &(elf_section_data(section)->this_hdr);
5893               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5894                 {
5895                   map->sections[isec++] = section->output_section;
5896                   if (isec == section_count)
5897                     break;
5898                 }
5899             }
5900         }
5901
5902       map->count = section_count;
5903       *pointer_to_map = map;
5904       pointer_to_map = &map->next;
5905     }
5906
5907   elf_tdata (obfd)->segment_map = map_first;
5908   return TRUE;
5909 }
5910
5911 /* Copy private BFD data.  This copies or rewrites ELF program header
5912    information.  */
5913
5914 static bfd_boolean
5915 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5916 {
5917   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5918       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5919     return TRUE;
5920
5921   if (elf_tdata (ibfd)->phdr == NULL)
5922     return TRUE;
5923
5924   if (ibfd->xvec == obfd->xvec)
5925     {
5926       /* Check to see if any sections in the input BFD
5927          covered by ELF program header have changed.  */
5928       Elf_Internal_Phdr *segment;
5929       asection *section, *osec;
5930       unsigned int i, num_segments;
5931       Elf_Internal_Shdr *this_hdr;
5932       const struct elf_backend_data *bed;
5933
5934       bed = get_elf_backend_data (ibfd);
5935
5936       /* Regenerate the segment map if p_paddr is set to 0.  */
5937       if (bed->want_p_paddr_set_to_zero)
5938         goto rewrite;
5939
5940       /* Initialize the segment mark field.  */
5941       for (section = obfd->sections; section != NULL;
5942            section = section->next)
5943         section->segment_mark = FALSE;
5944
5945       num_segments = elf_elfheader (ibfd)->e_phnum;
5946       for (i = 0, segment = elf_tdata (ibfd)->phdr;
5947            i < num_segments;
5948            i++, segment++)
5949         {
5950           /* PR binutils/3535.  The Solaris linker always sets the p_paddr
5951              and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5952              which severly confuses things, so always regenerate the segment
5953              map in this case.  */
5954           if (segment->p_paddr == 0
5955               && segment->p_memsz == 0
5956               && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
5957             goto rewrite;
5958
5959           for (section = ibfd->sections;
5960                section != NULL; section = section->next)
5961             {
5962               /* We mark the output section so that we know it comes
5963                  from the input BFD.  */
5964               osec = section->output_section;
5965               if (osec)
5966                 osec->segment_mark = TRUE;
5967
5968               /* Check if this section is covered by the segment.  */
5969               this_hdr = &(elf_section_data(section)->this_hdr);
5970               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5971                 {
5972                   /* FIXME: Check if its output section is changed or
5973                      removed.  What else do we need to check?  */
5974                   if (osec == NULL
5975                       || section->flags != osec->flags
5976                       || section->lma != osec->lma
5977                       || section->vma != osec->vma
5978                       || section->size != osec->size
5979                       || section->rawsize != osec->rawsize
5980                       || section->alignment_power != osec->alignment_power)
5981                     goto rewrite;
5982                 }
5983             }
5984         }
5985
5986       /* Check to see if any output section do not come from the
5987          input BFD.  */
5988       for (section = obfd->sections; section != NULL;
5989            section = section->next)
5990         {
5991           if (section->segment_mark == FALSE)
5992             goto rewrite;
5993           else
5994             section->segment_mark = FALSE;
5995         }
5996
5997       return copy_elf_program_header (ibfd, obfd);
5998     }
5999
6000 rewrite:
6001   return rewrite_elf_program_header (ibfd, obfd);
6002 }
6003
6004 /* Initialize private output section information from input section.  */
6005
6006 bfd_boolean
6007 _bfd_elf_init_private_section_data (bfd *ibfd,
6008                                     asection *isec,
6009                                     bfd *obfd,
6010                                     asection *osec,
6011                                     struct bfd_link_info *link_info)
6012
6013 {
6014   Elf_Internal_Shdr *ihdr, *ohdr;
6015   bfd_boolean need_group = link_info == NULL || link_info->relocatable;
6016
6017   if (ibfd->xvec->flavour != bfd_target_elf_flavour
6018       || obfd->xvec->flavour != bfd_target_elf_flavour)
6019     return TRUE;
6020
6021   /* Don't copy the output ELF section type from input if the
6022      output BFD section flags have been set to something different.
6023      elf_fake_sections will set ELF section type based on BFD
6024      section flags.  */
6025   if (elf_section_type (osec) == SHT_NULL
6026       && (osec->flags == isec->flags || !osec->flags))
6027     elf_section_type (osec) = elf_section_type (isec);
6028
6029   /* FIXME: Is this correct for all OS/PROC specific flags?  */
6030   elf_section_flags (osec) |= (elf_section_flags (isec)
6031                                & (SHF_MASKOS | SHF_MASKPROC));
6032
6033   /* Set things up for objcopy and relocatable link.  The output
6034      SHT_GROUP section will have its elf_next_in_group pointing back
6035      to the input group members.  Ignore linker created group section.
6036      See elfNN_ia64_object_p in elfxx-ia64.c.  */
6037   if (need_group)
6038     {
6039       if (elf_sec_group (isec) == NULL
6040           || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6041         {
6042           if (elf_section_flags (isec) & SHF_GROUP)
6043             elf_section_flags (osec) |= SHF_GROUP;
6044           elf_next_in_group (osec) = elf_next_in_group (isec);
6045           elf_section_data (osec)->group = elf_section_data (isec)->group;
6046         }
6047     }
6048
6049   ihdr = &elf_section_data (isec)->this_hdr;
6050
6051   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6052      don't use the output section of the linked-to section since it
6053      may be NULL at this point.  */
6054   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6055     {
6056       ohdr = &elf_section_data (osec)->this_hdr;
6057       ohdr->sh_flags |= SHF_LINK_ORDER;
6058       elf_linked_to_section (osec) = elf_linked_to_section (isec);
6059     }
6060
6061   osec->use_rela_p = isec->use_rela_p;
6062
6063   return TRUE;
6064 }
6065
6066 /* Copy private section information.  This copies over the entsize
6067    field, and sometimes the info field.  */
6068
6069 bfd_boolean
6070 _bfd_elf_copy_private_section_data (bfd *ibfd,
6071                                     asection *isec,
6072                                     bfd *obfd,
6073                                     asection *osec)
6074 {
6075   Elf_Internal_Shdr *ihdr, *ohdr;
6076
6077   if (ibfd->xvec->flavour != bfd_target_elf_flavour
6078       || obfd->xvec->flavour != bfd_target_elf_flavour)
6079     return TRUE;
6080
6081   ihdr = &elf_section_data (isec)->this_hdr;
6082   ohdr = &elf_section_data (osec)->this_hdr;
6083
6084   ohdr->sh_entsize = ihdr->sh_entsize;
6085
6086   if (ihdr->sh_type == SHT_SYMTAB
6087       || ihdr->sh_type == SHT_DYNSYM
6088       || ihdr->sh_type == SHT_GNU_verneed
6089       || ihdr->sh_type == SHT_GNU_verdef)
6090     ohdr->sh_info = ihdr->sh_info;
6091
6092   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6093                                              NULL);
6094 }
6095
6096 /* Copy private header information.  */
6097
6098 bfd_boolean
6099 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6100 {
6101   asection *isec;
6102
6103   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6104       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6105     return TRUE;
6106
6107   /* Copy over private BFD data if it has not already been copied.
6108      This must be done here, rather than in the copy_private_bfd_data
6109      entry point, because the latter is called after the section
6110      contents have been set, which means that the program headers have
6111      already been worked out.  */
6112   if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6113     {
6114       if (! copy_private_bfd_data (ibfd, obfd))
6115         return FALSE;
6116     }
6117
6118   /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6119      but this might be wrong if we deleted the group section.  */
6120   for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6121     if (elf_section_type (isec) == SHT_GROUP
6122         && isec->output_section == NULL)
6123       {
6124         asection *first = elf_next_in_group (isec);
6125         asection *s = first;
6126         while (s != NULL)
6127           {
6128             if (s->output_section != NULL)
6129               {
6130                 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6131                 elf_group_name (s->output_section) = NULL;
6132               }
6133             s = elf_next_in_group (s);
6134             if (s == first)
6135               break;
6136           }
6137       }
6138
6139   return TRUE;
6140 }
6141
6142 /* Copy private symbol information.  If this symbol is in a section
6143    which we did not map into a BFD section, try to map the section
6144    index correctly.  We use special macro definitions for the mapped
6145    section indices; these definitions are interpreted by the
6146    swap_out_syms function.  */
6147
6148 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6149 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6150 #define MAP_STRTAB    (SHN_HIOS + 3)
6151 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
6152 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6153
6154 bfd_boolean
6155 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6156                                    asymbol *isymarg,
6157                                    bfd *obfd,
6158                                    asymbol *osymarg)
6159 {
6160   elf_symbol_type *isym, *osym;
6161
6162   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6163       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6164     return TRUE;
6165
6166   isym = elf_symbol_from (ibfd, isymarg);
6167   osym = elf_symbol_from (obfd, osymarg);
6168
6169   if (isym != NULL
6170       && isym->internal_elf_sym.st_shndx != 0
6171       && osym != NULL
6172       && bfd_is_abs_section (isym->symbol.section))
6173     {
6174       unsigned int shndx;
6175
6176       shndx = isym->internal_elf_sym.st_shndx;
6177       if (shndx == elf_onesymtab (ibfd))
6178         shndx = MAP_ONESYMTAB;
6179       else if (shndx == elf_dynsymtab (ibfd))
6180         shndx = MAP_DYNSYMTAB;
6181       else if (shndx == elf_tdata (ibfd)->strtab_section)
6182         shndx = MAP_STRTAB;
6183       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6184         shndx = MAP_SHSTRTAB;
6185       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6186         shndx = MAP_SYM_SHNDX;
6187       osym->internal_elf_sym.st_shndx = shndx;
6188     }
6189
6190   return TRUE;
6191 }
6192
6193 /* Swap out the symbols.  */
6194
6195 static bfd_boolean
6196 swap_out_syms (bfd *abfd,
6197                struct bfd_strtab_hash **sttp,
6198                int relocatable_p)
6199 {
6200   const struct elf_backend_data *bed;
6201   int symcount;
6202   asymbol **syms;
6203   struct bfd_strtab_hash *stt;
6204   Elf_Internal_Shdr *symtab_hdr;
6205   Elf_Internal_Shdr *symtab_shndx_hdr;
6206   Elf_Internal_Shdr *symstrtab_hdr;
6207   bfd_byte *outbound_syms;
6208   bfd_byte *outbound_shndx;
6209   int idx;
6210   bfd_size_type amt;
6211   bfd_boolean name_local_sections;
6212
6213   if (!elf_map_symbols (abfd))
6214     return FALSE;
6215
6216   /* Dump out the symtabs.  */
6217   stt = _bfd_elf_stringtab_init ();
6218   if (stt == NULL)
6219     return FALSE;
6220
6221   bed = get_elf_backend_data (abfd);
6222   symcount = bfd_get_symcount (abfd);
6223   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6224   symtab_hdr->sh_type = SHT_SYMTAB;
6225   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6226   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6227   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6228   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
6229
6230   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6231   symstrtab_hdr->sh_type = SHT_STRTAB;
6232
6233   outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
6234   if (outbound_syms == NULL)
6235     {
6236       _bfd_stringtab_free (stt);
6237       return FALSE;
6238     }
6239   symtab_hdr->contents = outbound_syms;
6240
6241   outbound_shndx = NULL;
6242   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6243   if (symtab_shndx_hdr->sh_name != 0)
6244     {
6245       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6246       outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
6247                                     sizeof (Elf_External_Sym_Shndx));
6248       if (outbound_shndx == NULL)
6249         {
6250           _bfd_stringtab_free (stt);
6251           return FALSE;
6252         }
6253
6254       symtab_shndx_hdr->contents = outbound_shndx;
6255       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6256       symtab_shndx_hdr->sh_size = amt;
6257       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6258       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6259     }
6260
6261   /* Now generate the data (for "contents").  */
6262   {
6263     /* Fill in zeroth symbol and swap it out.  */
6264     Elf_Internal_Sym sym;
6265     sym.st_name = 0;
6266     sym.st_value = 0;
6267     sym.st_size = 0;
6268     sym.st_info = 0;
6269     sym.st_other = 0;
6270     sym.st_shndx = SHN_UNDEF;
6271     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6272     outbound_syms += bed->s->sizeof_sym;
6273     if (outbound_shndx != NULL)
6274       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6275   }
6276
6277   name_local_sections
6278     = (bed->elf_backend_name_local_section_symbols
6279        && bed->elf_backend_name_local_section_symbols (abfd));
6280
6281   syms = bfd_get_outsymbols (abfd);
6282   for (idx = 0; idx < symcount; idx++)
6283     {
6284       Elf_Internal_Sym sym;
6285       bfd_vma value = syms[idx]->value;
6286       elf_symbol_type *type_ptr;
6287       flagword flags = syms[idx]->flags;
6288       int type;
6289
6290       if (!name_local_sections
6291           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6292         {
6293           /* Local section symbols have no name.  */
6294           sym.st_name = 0;
6295         }
6296       else
6297         {
6298           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6299                                                             syms[idx]->name,
6300                                                             TRUE, FALSE);
6301           if (sym.st_name == (unsigned long) -1)
6302             {
6303               _bfd_stringtab_free (stt);
6304               return FALSE;
6305             }
6306         }
6307
6308       type_ptr = elf_symbol_from (abfd, syms[idx]);
6309
6310       if ((flags & BSF_SECTION_SYM) == 0
6311           && bfd_is_com_section (syms[idx]->section))
6312         {
6313           /* ELF common symbols put the alignment into the `value' field,
6314              and the size into the `size' field.  This is backwards from
6315              how BFD handles it, so reverse it here.  */
6316           sym.st_size = value;
6317           if (type_ptr == NULL
6318               || type_ptr->internal_elf_sym.st_value == 0)
6319             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6320           else
6321             sym.st_value = type_ptr->internal_elf_sym.st_value;
6322           sym.st_shndx = _bfd_elf_section_from_bfd_section
6323             (abfd, syms[idx]->section);
6324         }
6325       else
6326         {
6327           asection *sec = syms[idx]->section;
6328           unsigned int shndx;
6329
6330           if (sec->output_section)
6331             {
6332               value += sec->output_offset;
6333               sec = sec->output_section;
6334             }
6335
6336           /* Don't add in the section vma for relocatable output.  */
6337           if (! relocatable_p)
6338             value += sec->vma;
6339           sym.st_value = value;
6340           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6341
6342           if (bfd_is_abs_section (sec)
6343               && type_ptr != NULL
6344               && type_ptr->internal_elf_sym.st_shndx != 0)
6345             {
6346               /* This symbol is in a real ELF section which we did
6347                  not create as a BFD section.  Undo the mapping done
6348                  by copy_private_symbol_data.  */
6349               shndx = type_ptr->internal_elf_sym.st_shndx;
6350               switch (shndx)
6351                 {
6352                 case MAP_ONESYMTAB:
6353                   shndx = elf_onesymtab (abfd);
6354                   break;
6355                 case MAP_DYNSYMTAB:
6356                   shndx = elf_dynsymtab (abfd);
6357                   break;
6358                 case MAP_STRTAB:
6359                   shndx = elf_tdata (abfd)->strtab_section;
6360                   break;
6361                 case MAP_SHSTRTAB:
6362                   shndx = elf_tdata (abfd)->shstrtab_section;
6363                   break;
6364                 case MAP_SYM_SHNDX:
6365                   shndx = elf_tdata (abfd)->symtab_shndx_section;
6366                   break;
6367                 default:
6368                   break;
6369                 }
6370             }
6371           else
6372             {
6373               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6374
6375               if (shndx == SHN_BAD)
6376                 {
6377                   asection *sec2;
6378
6379                   /* Writing this would be a hell of a lot easier if
6380                      we had some decent documentation on bfd, and
6381                      knew what to expect of the library, and what to
6382                      demand of applications.  For example, it
6383                      appears that `objcopy' might not set the
6384                      section of a symbol to be a section that is
6385                      actually in the output file.  */
6386                   sec2 = bfd_get_section_by_name (abfd, sec->name);
6387                   if (sec2 == NULL)
6388                     {
6389                       _bfd_error_handler (_("\
6390 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6391                                           syms[idx]->name ? syms[idx]->name : "<Local sym>",
6392                                           sec->name);
6393                       bfd_set_error (bfd_error_invalid_operation);
6394                       _bfd_stringtab_free (stt);
6395                       return FALSE;
6396                     }
6397
6398                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6399                   BFD_ASSERT (shndx != SHN_BAD);
6400                 }
6401             }
6402
6403           sym.st_shndx = shndx;
6404         }
6405
6406       if ((flags & BSF_THREAD_LOCAL) != 0)
6407         type = STT_TLS;
6408       else if ((flags & BSF_FUNCTION) != 0)
6409         type = STT_FUNC;
6410       else if ((flags & BSF_OBJECT) != 0)
6411         type = STT_OBJECT;
6412       else if ((flags & BSF_RELC) != 0)
6413         type = STT_RELC;
6414       else if ((flags & BSF_SRELC) != 0)
6415         type = STT_SRELC;
6416       else
6417         type = STT_NOTYPE;
6418
6419       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6420         type = STT_TLS;
6421
6422       /* Processor-specific types.  */
6423       if (type_ptr != NULL
6424           && bed->elf_backend_get_symbol_type)
6425         type = ((*bed->elf_backend_get_symbol_type)
6426                 (&type_ptr->internal_elf_sym, type));
6427
6428       if (flags & BSF_SECTION_SYM)
6429         {
6430           if (flags & BSF_GLOBAL)
6431             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6432           else
6433             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6434         }
6435       else if (bfd_is_com_section (syms[idx]->section))
6436         {
6437 #ifdef USE_STT_COMMON
6438           if (type == STT_OBJECT)
6439             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6440           else
6441 #else
6442             sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6443 #endif
6444         }
6445       else if (bfd_is_und_section (syms[idx]->section))
6446         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6447                                     ? STB_WEAK
6448                                     : STB_GLOBAL),
6449                                    type);
6450       else if (flags & BSF_FILE)
6451         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6452       else
6453         {
6454           int bind = STB_LOCAL;
6455
6456           if (flags & BSF_LOCAL)
6457             bind = STB_LOCAL;
6458           else if (flags & BSF_WEAK)
6459             bind = STB_WEAK;
6460           else if (flags & BSF_GLOBAL)
6461             bind = STB_GLOBAL;
6462
6463           sym.st_info = ELF_ST_INFO (bind, type);
6464         }
6465
6466       if (type_ptr != NULL)
6467         sym.st_other = type_ptr->internal_elf_sym.st_other;
6468       else
6469         sym.st_other = 0;
6470
6471       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6472       outbound_syms += bed->s->sizeof_sym;
6473       if (outbound_shndx != NULL)
6474         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6475     }
6476
6477   *sttp = stt;
6478   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6479   symstrtab_hdr->sh_type = SHT_STRTAB;
6480
6481   symstrtab_hdr->sh_flags = 0;
6482   symstrtab_hdr->sh_addr = 0;
6483   symstrtab_hdr->sh_entsize = 0;
6484   symstrtab_hdr->sh_link = 0;
6485   symstrtab_hdr->sh_info = 0;
6486   symstrtab_hdr->sh_addralign = 1;
6487
6488   return TRUE;
6489 }
6490
6491 /* Return the number of bytes required to hold the symtab vector.
6492
6493    Note that we base it on the count plus 1, since we will null terminate
6494    the vector allocated based on this size.  However, the ELF symbol table
6495    always has a dummy entry as symbol #0, so it ends up even.  */
6496
6497 long
6498 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6499 {
6500   long symcount;
6501   long symtab_size;
6502   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6503
6504   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6505   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6506   if (symcount > 0)
6507     symtab_size -= sizeof (asymbol *);
6508
6509   return symtab_size;
6510 }
6511
6512 long
6513 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6514 {
6515   long symcount;
6516   long symtab_size;
6517   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6518
6519   if (elf_dynsymtab (abfd) == 0)
6520     {
6521       bfd_set_error (bfd_error_invalid_operation);
6522       return -1;
6523     }
6524
6525   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6526   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6527   if (symcount > 0)
6528     symtab_size -= sizeof (asymbol *);
6529
6530   return symtab_size;
6531 }
6532
6533 long
6534 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6535                                 sec_ptr asect)
6536 {
6537   return (asect->reloc_count + 1) * sizeof (arelent *);
6538 }
6539
6540 /* Canonicalize the relocs.  */
6541
6542 long
6543 _bfd_elf_canonicalize_reloc (bfd *abfd,
6544                              sec_ptr section,
6545                              arelent **relptr,
6546                              asymbol **symbols)
6547 {
6548   arelent *tblptr;
6549   unsigned int i;
6550   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6551
6552   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6553     return -1;
6554
6555   tblptr = section->relocation;
6556   for (i = 0; i < section->reloc_count; i++)
6557     *relptr++ = tblptr++;
6558
6559   *relptr = NULL;
6560
6561   return section->reloc_count;
6562 }
6563
6564 long
6565 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6566 {
6567   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6568   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6569
6570   if (symcount >= 0)
6571     bfd_get_symcount (abfd) = symcount;
6572   return symcount;
6573 }
6574
6575 long
6576 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6577                                       asymbol **allocation)
6578 {
6579   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6580   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6581
6582   if (symcount >= 0)
6583     bfd_get_dynamic_symcount (abfd) = symcount;
6584   return symcount;
6585 }
6586
6587 /* Return the size required for the dynamic reloc entries.  Any loadable
6588    section that was actually installed in the BFD, and has type SHT_REL
6589    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6590    dynamic reloc section.  */
6591
6592 long
6593 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6594 {
6595   long ret;
6596   asection *s;
6597
6598   if (elf_dynsymtab (abfd) == 0)
6599     {
6600       bfd_set_error (bfd_error_invalid_operation);
6601       return -1;
6602     }
6603
6604   ret = sizeof (arelent *);
6605   for (s = abfd->sections; s != NULL; s = s->next)
6606     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6607         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6608             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6609       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6610               * sizeof (arelent *));
6611
6612   return ret;
6613 }
6614
6615 /* Canonicalize the dynamic relocation entries.  Note that we return the
6616    dynamic relocations as a single block, although they are actually
6617    associated with particular sections; the interface, which was
6618    designed for SunOS style shared libraries, expects that there is only
6619    one set of dynamic relocs.  Any loadable section that was actually
6620    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6621    dynamic symbol table, is considered to be a dynamic reloc section.  */
6622
6623 long
6624 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6625                                      arelent **storage,
6626                                      asymbol **syms)
6627 {
6628   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6629   asection *s;
6630   long ret;
6631
6632   if (elf_dynsymtab (abfd) == 0)
6633     {
6634       bfd_set_error (bfd_error_invalid_operation);
6635       return -1;
6636     }
6637
6638   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6639   ret = 0;
6640   for (s = abfd->sections; s != NULL; s = s->next)
6641     {
6642       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6643           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6644               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6645         {
6646           arelent *p;
6647           long count, i;
6648
6649           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6650             return -1;
6651           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6652           p = s->relocation;
6653           for (i = 0; i < count; i++)
6654             *storage++ = p++;
6655           ret += count;
6656         }
6657     }
6658
6659   *storage = NULL;
6660
6661   return ret;
6662 }
6663 \f
6664 /* Read in the version information.  */
6665
6666 bfd_boolean
6667 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6668 {
6669   bfd_byte *contents = NULL;
6670   unsigned int freeidx = 0;
6671
6672   if (elf_dynverref (abfd) != 0)
6673     {
6674       Elf_Internal_Shdr *hdr;
6675       Elf_External_Verneed *everneed;
6676       Elf_Internal_Verneed *iverneed;
6677       unsigned int i;
6678       bfd_byte *contents_end;
6679
6680       hdr = &elf_tdata (abfd)->dynverref_hdr;
6681
6682       elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6683                                               sizeof (Elf_Internal_Verneed));
6684       if (elf_tdata (abfd)->verref == NULL)
6685         goto error_return;
6686
6687       elf_tdata (abfd)->cverrefs = hdr->sh_info;
6688
6689       contents = bfd_malloc (hdr->sh_size);
6690       if (contents == NULL)
6691         {
6692 error_return_verref:
6693           elf_tdata (abfd)->verref = NULL;
6694           elf_tdata (abfd)->cverrefs = 0;
6695           goto error_return;
6696         }
6697       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6698           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6699         goto error_return_verref;
6700
6701       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6702         goto error_return_verref;
6703
6704       BFD_ASSERT (sizeof (Elf_External_Verneed)
6705                   == sizeof (Elf_External_Vernaux));
6706       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6707       everneed = (Elf_External_Verneed *) contents;
6708       iverneed = elf_tdata (abfd)->verref;
6709       for (i = 0; i < hdr->sh_info; i++, iverneed++)
6710         {
6711           Elf_External_Vernaux *evernaux;
6712           Elf_Internal_Vernaux *ivernaux;
6713           unsigned int j;
6714
6715           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6716
6717           iverneed->vn_bfd = abfd;
6718
6719           iverneed->vn_filename =
6720             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6721                                              iverneed->vn_file);
6722           if (iverneed->vn_filename == NULL)
6723             goto error_return_verref;
6724
6725           if (iverneed->vn_cnt == 0)
6726             iverneed->vn_auxptr = NULL;
6727           else
6728             {
6729               iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6730                                                 sizeof (Elf_Internal_Vernaux));
6731               if (iverneed->vn_auxptr == NULL)
6732                 goto error_return_verref;
6733             }
6734
6735           if (iverneed->vn_aux
6736               > (size_t) (contents_end - (bfd_byte *) everneed))
6737             goto error_return_verref;
6738
6739           evernaux = ((Elf_External_Vernaux *)
6740                       ((bfd_byte *) everneed + iverneed->vn_aux));
6741           ivernaux = iverneed->vn_auxptr;
6742           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6743             {
6744               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6745
6746               ivernaux->vna_nodename =
6747                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6748                                                  ivernaux->vna_name);
6749               if (ivernaux->vna_nodename == NULL)
6750                 goto error_return_verref;
6751
6752               if (j + 1 < iverneed->vn_cnt)
6753                 ivernaux->vna_nextptr = ivernaux + 1;
6754               else
6755                 ivernaux->vna_nextptr = NULL;
6756
6757               if (ivernaux->vna_next
6758                   > (size_t) (contents_end - (bfd_byte *) evernaux))
6759                 goto error_return_verref;
6760
6761               evernaux = ((Elf_External_Vernaux *)
6762                           ((bfd_byte *) evernaux + ivernaux->vna_next));
6763
6764               if (ivernaux->vna_other > freeidx)
6765                 freeidx = ivernaux->vna_other;
6766             }
6767
6768           if (i + 1 < hdr->sh_info)
6769             iverneed->vn_nextref = iverneed + 1;
6770           else
6771             iverneed->vn_nextref = NULL;
6772
6773           if (iverneed->vn_next
6774               > (size_t) (contents_end - (bfd_byte *) everneed))
6775             goto error_return_verref;
6776
6777           everneed = ((Elf_External_Verneed *)
6778                       ((bfd_byte *) everneed + iverneed->vn_next));
6779         }
6780
6781       free (contents);
6782       contents = NULL;
6783     }
6784
6785   if (elf_dynverdef (abfd) != 0)
6786     {
6787       Elf_Internal_Shdr *hdr;
6788       Elf_External_Verdef *everdef;
6789       Elf_Internal_Verdef *iverdef;
6790       Elf_Internal_Verdef *iverdefarr;
6791       Elf_Internal_Verdef iverdefmem;
6792       unsigned int i;
6793       unsigned int maxidx;
6794       bfd_byte *contents_end_def, *contents_end_aux;
6795
6796       hdr = &elf_tdata (abfd)->dynverdef_hdr;
6797
6798       contents = bfd_malloc (hdr->sh_size);
6799       if (contents == NULL)
6800         goto error_return;
6801       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6802           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6803         goto error_return;
6804
6805       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6806         goto error_return;
6807
6808       BFD_ASSERT (sizeof (Elf_External_Verdef)
6809                   >= sizeof (Elf_External_Verdaux));
6810       contents_end_def = contents + hdr->sh_size
6811                          - sizeof (Elf_External_Verdef);
6812       contents_end_aux = contents + hdr->sh_size
6813                          - sizeof (Elf_External_Verdaux);
6814
6815       /* We know the number of entries in the section but not the maximum
6816          index.  Therefore we have to run through all entries and find
6817          the maximum.  */
6818       everdef = (Elf_External_Verdef *) contents;
6819       maxidx = 0;
6820       for (i = 0; i < hdr->sh_info; ++i)
6821         {
6822           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6823
6824           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6825             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6826
6827           if (iverdefmem.vd_next
6828               > (size_t) (contents_end_def - (bfd_byte *) everdef))
6829             goto error_return;
6830
6831           everdef = ((Elf_External_Verdef *)
6832                      ((bfd_byte *) everdef + iverdefmem.vd_next));
6833         }
6834
6835       if (default_imported_symver)
6836         {
6837           if (freeidx > maxidx)
6838             maxidx = ++freeidx;
6839           else
6840             freeidx = ++maxidx;
6841         }
6842       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6843                                               sizeof (Elf_Internal_Verdef));
6844       if (elf_tdata (abfd)->verdef == NULL)
6845         goto error_return;
6846
6847       elf_tdata (abfd)->cverdefs = maxidx;
6848
6849       everdef = (Elf_External_Verdef *) contents;
6850       iverdefarr = elf_tdata (abfd)->verdef;
6851       for (i = 0; i < hdr->sh_info; i++)
6852         {
6853           Elf_External_Verdaux *everdaux;
6854           Elf_Internal_Verdaux *iverdaux;
6855           unsigned int j;
6856
6857           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6858
6859           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6860             {
6861 error_return_verdef:
6862               elf_tdata (abfd)->verdef = NULL;
6863               elf_tdata (abfd)->cverdefs = 0;
6864               goto error_return;
6865             }
6866
6867           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6868           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6869
6870           iverdef->vd_bfd = abfd;
6871
6872           if (iverdef->vd_cnt == 0)
6873             iverdef->vd_auxptr = NULL;
6874           else
6875             {
6876               iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6877                                                sizeof (Elf_Internal_Verdaux));
6878               if (iverdef->vd_auxptr == NULL)
6879                 goto error_return_verdef;
6880             }
6881
6882           if (iverdef->vd_aux
6883               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6884             goto error_return_verdef;
6885
6886           everdaux = ((Elf_External_Verdaux *)
6887                       ((bfd_byte *) everdef + iverdef->vd_aux));
6888           iverdaux = iverdef->vd_auxptr;
6889           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6890             {
6891               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6892
6893               iverdaux->vda_nodename =
6894                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6895                                                  iverdaux->vda_name);
6896               if (iverdaux->vda_nodename == NULL)
6897                 goto error_return_verdef;
6898
6899               if (j + 1 < iverdef->vd_cnt)
6900                 iverdaux->vda_nextptr = iverdaux + 1;
6901               else
6902                 iverdaux->vda_nextptr = NULL;
6903
6904               if (iverdaux->vda_next
6905                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6906                 goto error_return_verdef;
6907
6908               everdaux = ((Elf_External_Verdaux *)
6909                           ((bfd_byte *) everdaux + iverdaux->vda_next));
6910             }
6911
6912           if (iverdef->vd_cnt)
6913             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6914
6915           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
6916             iverdef->vd_nextdef = iverdef + 1;
6917           else
6918             iverdef->vd_nextdef = NULL;
6919
6920           everdef = ((Elf_External_Verdef *)
6921                      ((bfd_byte *) everdef + iverdef->vd_next));
6922         }
6923
6924       free (contents);
6925       contents = NULL;
6926     }
6927   else if (default_imported_symver)
6928     {
6929       if (freeidx < 3)
6930         freeidx = 3;
6931       else
6932         freeidx++;
6933
6934       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6935                                               sizeof (Elf_Internal_Verdef));
6936       if (elf_tdata (abfd)->verdef == NULL)
6937         goto error_return;
6938
6939       elf_tdata (abfd)->cverdefs = freeidx;
6940     }
6941
6942   /* Create a default version based on the soname.  */
6943   if (default_imported_symver)
6944     {
6945       Elf_Internal_Verdef *iverdef;
6946       Elf_Internal_Verdaux *iverdaux;
6947
6948       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6949
6950       iverdef->vd_version = VER_DEF_CURRENT;
6951       iverdef->vd_flags = 0;
6952       iverdef->vd_ndx = freeidx;
6953       iverdef->vd_cnt = 1;
6954
6955       iverdef->vd_bfd = abfd;
6956
6957       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6958       if (iverdef->vd_nodename == NULL)
6959         goto error_return_verdef;
6960       iverdef->vd_nextdef = NULL;
6961       iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6962       if (iverdef->vd_auxptr == NULL)
6963         goto error_return_verdef;
6964
6965       iverdaux = iverdef->vd_auxptr;
6966       iverdaux->vda_nodename = iverdef->vd_nodename;
6967       iverdaux->vda_nextptr = NULL;
6968     }
6969
6970   return TRUE;
6971
6972  error_return:
6973   if (contents != NULL)
6974     free (contents);
6975   return FALSE;
6976 }
6977 \f
6978 asymbol *
6979 _bfd_elf_make_empty_symbol (bfd *abfd)
6980 {
6981   elf_symbol_type *newsym;
6982   bfd_size_type amt = sizeof (elf_symbol_type);
6983
6984   newsym = bfd_zalloc (abfd, amt);
6985   if (!newsym)
6986     return NULL;
6987   else
6988     {
6989       newsym->symbol.the_bfd = abfd;
6990       return &newsym->symbol;
6991     }
6992 }
6993
6994 void
6995 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6996                           asymbol *symbol,
6997                           symbol_info *ret)
6998 {
6999   bfd_symbol_info (symbol, ret);
7000 }
7001
7002 /* Return whether a symbol name implies a local symbol.  Most targets
7003    use this function for the is_local_label_name entry point, but some
7004    override it.  */
7005
7006 bfd_boolean
7007 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7008                               const char *name)
7009 {
7010   /* Normal local symbols start with ``.L''.  */
7011   if (name[0] == '.' && name[1] == 'L')
7012     return TRUE;
7013
7014   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7015      DWARF debugging symbols starting with ``..''.  */
7016   if (name[0] == '.' && name[1] == '.')
7017     return TRUE;
7018
7019   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7020      emitting DWARF debugging output.  I suspect this is actually a
7021      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7022      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7023      underscore to be emitted on some ELF targets).  For ease of use,
7024      we treat such symbols as local.  */
7025   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
7026     return TRUE;
7027
7028   return FALSE;
7029 }
7030
7031 alent *
7032 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7033                      asymbol *symbol ATTRIBUTE_UNUSED)
7034 {
7035   abort ();
7036   return NULL;
7037 }
7038
7039 bfd_boolean
7040 _bfd_elf_set_arch_mach (bfd *abfd,
7041                         enum bfd_architecture arch,
7042                         unsigned long machine)
7043 {
7044   /* If this isn't the right architecture for this backend, and this
7045      isn't the generic backend, fail.  */
7046   if (arch != get_elf_backend_data (abfd)->arch
7047       && arch != bfd_arch_unknown
7048       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
7049     return FALSE;
7050
7051   return bfd_default_set_arch_mach (abfd, arch, machine);
7052 }
7053
7054 /* Find the function to a particular section and offset,
7055    for error reporting.  */
7056
7057 static bfd_boolean
7058 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
7059                    asection *section,
7060                    asymbol **symbols,
7061                    bfd_vma offset,
7062                    const char **filename_ptr,
7063                    const char **functionname_ptr)
7064 {
7065   const char *filename;
7066   asymbol *func, *file;
7067   bfd_vma low_func;
7068   asymbol **p;
7069   /* ??? Given multiple file symbols, it is impossible to reliably
7070      choose the right file name for global symbols.  File symbols are
7071      local symbols, and thus all file symbols must sort before any
7072      global symbols.  The ELF spec may be interpreted to say that a
7073      file symbol must sort before other local symbols, but currently
7074      ld -r doesn't do this.  So, for ld -r output, it is possible to
7075      make a better choice of file name for local symbols by ignoring
7076      file symbols appearing after a given local symbol.  */
7077   enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7078
7079   filename = NULL;
7080   func = NULL;
7081   file = NULL;
7082   low_func = 0;
7083   state = nothing_seen;
7084
7085   for (p = symbols; *p != NULL; p++)
7086     {
7087       elf_symbol_type *q;
7088
7089       q = (elf_symbol_type *) *p;
7090
7091       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7092         {
7093         default:
7094           break;
7095         case STT_FILE:
7096           file = &q->symbol;
7097           if (state == symbol_seen)
7098             state = file_after_symbol_seen;
7099           continue;
7100         case STT_NOTYPE:
7101         case STT_FUNC:
7102           if (bfd_get_section (&q->symbol) == section
7103               && q->symbol.value >= low_func
7104               && q->symbol.value <= offset)
7105             {
7106               func = (asymbol *) q;
7107               low_func = q->symbol.value;
7108               filename = NULL;
7109               if (file != NULL
7110                   && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
7111                       || state != file_after_symbol_seen))
7112                 filename = bfd_asymbol_name (file);
7113             }
7114           break;
7115         }
7116       if (state == nothing_seen)
7117         state = symbol_seen;
7118     }
7119
7120   if (func == NULL)
7121     return FALSE;
7122
7123   if (filename_ptr)
7124     *filename_ptr = filename;
7125   if (functionname_ptr)
7126     *functionname_ptr = bfd_asymbol_name (func);
7127
7128   return TRUE;
7129 }
7130
7131 /* Find the nearest line to a particular section and offset,
7132    for error reporting.  */
7133
7134 bfd_boolean
7135 _bfd_elf_find_nearest_line (bfd *abfd,
7136                             asection *section,
7137                             asymbol **symbols,
7138                             bfd_vma offset,
7139                             const char **filename_ptr,
7140                             const char **functionname_ptr,
7141                             unsigned int *line_ptr)
7142 {
7143   bfd_boolean found;
7144
7145   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7146                                      filename_ptr, functionname_ptr,
7147                                      line_ptr))
7148     {
7149       if (!*functionname_ptr)
7150         elf_find_function (abfd, section, symbols, offset,
7151                            *filename_ptr ? NULL : filename_ptr,
7152                            functionname_ptr);
7153
7154       return TRUE;
7155     }
7156
7157   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7158                                      filename_ptr, functionname_ptr,
7159                                      line_ptr, 0,
7160                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7161     {
7162       if (!*functionname_ptr)
7163         elf_find_function (abfd, section, symbols, offset,
7164                            *filename_ptr ? NULL : filename_ptr,
7165                            functionname_ptr);
7166
7167       return TRUE;
7168     }
7169
7170   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7171                                              &found, filename_ptr,
7172                                              functionname_ptr, line_ptr,
7173                                              &elf_tdata (abfd)->line_info))
7174     return FALSE;
7175   if (found && (*functionname_ptr || *line_ptr))
7176     return TRUE;
7177
7178   if (symbols == NULL)
7179     return FALSE;
7180
7181   if (! elf_find_function (abfd, section, symbols, offset,
7182                            filename_ptr, functionname_ptr))
7183     return FALSE;
7184
7185   *line_ptr = 0;
7186   return TRUE;
7187 }
7188
7189 /* Find the line for a symbol.  */
7190
7191 bfd_boolean
7192 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7193                     const char **filename_ptr, unsigned int *line_ptr)
7194 {
7195   return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7196                                 filename_ptr, line_ptr, 0,
7197                                 &elf_tdata (abfd)->dwarf2_find_line_info);
7198 }
7199
7200 /* After a call to bfd_find_nearest_line, successive calls to
7201    bfd_find_inliner_info can be used to get source information about
7202    each level of function inlining that terminated at the address
7203    passed to bfd_find_nearest_line.  Currently this is only supported
7204    for DWARF2 with appropriate DWARF3 extensions. */
7205
7206 bfd_boolean
7207 _bfd_elf_find_inliner_info (bfd *abfd,
7208                             const char **filename_ptr,
7209                             const char **functionname_ptr,
7210                             unsigned int *line_ptr)
7211 {
7212   bfd_boolean found;
7213   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7214                                          functionname_ptr, line_ptr,
7215                                          & elf_tdata (abfd)->dwarf2_find_line_info);
7216   return found;
7217 }
7218
7219 int
7220 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7221 {
7222   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7223   int ret = bed->s->sizeof_ehdr;
7224
7225   if (!info->relocatable)
7226     {
7227       bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7228
7229       if (phdr_size == (bfd_size_type) -1)
7230         {
7231           struct elf_segment_map *m;
7232
7233           phdr_size = 0;
7234           for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7235             phdr_size += bed->s->sizeof_phdr;
7236
7237           if (phdr_size == 0)
7238             phdr_size = get_program_header_size (abfd, info);
7239         }
7240
7241       elf_tdata (abfd)->program_header_size = phdr_size;
7242       ret += phdr_size;
7243     }
7244
7245   return ret;
7246 }
7247
7248 bfd_boolean
7249 _bfd_elf_set_section_contents (bfd *abfd,
7250                                sec_ptr section,
7251                                const void *location,
7252                                file_ptr offset,
7253                                bfd_size_type count)
7254 {
7255   Elf_Internal_Shdr *hdr;
7256   bfd_signed_vma pos;
7257
7258   if (! abfd->output_has_begun
7259       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7260     return FALSE;
7261
7262   hdr = &elf_section_data (section)->this_hdr;
7263   pos = hdr->sh_offset + offset;
7264   if (bfd_seek (abfd, pos, SEEK_SET) != 0
7265       || bfd_bwrite (location, count, abfd) != count)
7266     return FALSE;
7267
7268   return TRUE;
7269 }
7270
7271 void
7272 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7273                            arelent *cache_ptr ATTRIBUTE_UNUSED,
7274                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7275 {
7276   abort ();
7277 }
7278
7279 /* Try to convert a non-ELF reloc into an ELF one.  */
7280
7281 bfd_boolean
7282 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7283 {
7284   /* Check whether we really have an ELF howto.  */
7285
7286   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7287     {
7288       bfd_reloc_code_real_type code;
7289       reloc_howto_type *howto;
7290
7291       /* Alien reloc: Try to determine its type to replace it with an
7292          equivalent ELF reloc.  */
7293
7294       if (areloc->howto->pc_relative)
7295         {
7296           switch (areloc->howto->bitsize)
7297             {
7298             case 8:
7299               code = BFD_RELOC_8_PCREL;
7300               break;
7301             case 12:
7302               code = BFD_RELOC_12_PCREL;
7303               break;
7304             case 16:
7305               code = BFD_RELOC_16_PCREL;
7306               break;
7307             case 24:
7308               code = BFD_RELOC_24_PCREL;
7309               break;
7310             case 32:
7311               code = BFD_RELOC_32_PCREL;
7312               break;
7313             case 64:
7314               code = BFD_RELOC_64_PCREL;
7315               break;
7316             default:
7317               goto fail;
7318             }
7319
7320           howto = bfd_reloc_type_lookup (abfd, code);
7321
7322           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7323             {
7324               if (howto->pcrel_offset)
7325                 areloc->addend += areloc->address;
7326               else
7327                 areloc->addend -= areloc->address; /* addend is unsigned!! */
7328             }
7329         }
7330       else
7331         {
7332           switch (areloc->howto->bitsize)
7333             {
7334             case 8:
7335               code = BFD_RELOC_8;
7336               break;
7337             case 14:
7338               code = BFD_RELOC_14;
7339               break;
7340             case 16:
7341               code = BFD_RELOC_16;
7342               break;
7343             case 26:
7344               code = BFD_RELOC_26;
7345               break;
7346             case 32:
7347               code = BFD_RELOC_32;
7348               break;
7349             case 64:
7350               code = BFD_RELOC_64;
7351               break;
7352             default:
7353               goto fail;
7354             }
7355
7356           howto = bfd_reloc_type_lookup (abfd, code);
7357         }
7358
7359       if (howto)
7360         areloc->howto = howto;
7361       else
7362         goto fail;
7363     }
7364
7365   return TRUE;
7366
7367  fail:
7368   (*_bfd_error_handler)
7369     (_("%B: unsupported relocation type %s"),
7370      abfd, areloc->howto->name);
7371   bfd_set_error (bfd_error_bad_value);
7372   return FALSE;
7373 }
7374
7375 bfd_boolean
7376 _bfd_elf_close_and_cleanup (bfd *abfd)
7377 {
7378   if (bfd_get_format (abfd) == bfd_object)
7379     {
7380       if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
7381         _bfd_elf_strtab_free (elf_shstrtab (abfd));
7382       _bfd_dwarf2_cleanup_debug_info (abfd);
7383     }
7384
7385   return _bfd_generic_close_and_cleanup (abfd);
7386 }
7387
7388 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7389    in the relocation's offset.  Thus we cannot allow any sort of sanity
7390    range-checking to interfere.  There is nothing else to do in processing
7391    this reloc.  */
7392
7393 bfd_reloc_status_type
7394 _bfd_elf_rel_vtable_reloc_fn
7395   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7396    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7397    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7398    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7399 {
7400   return bfd_reloc_ok;
7401 }
7402 \f
7403 /* Elf core file support.  Much of this only works on native
7404    toolchains, since we rely on knowing the
7405    machine-dependent procfs structure in order to pick
7406    out details about the corefile.  */
7407
7408 #ifdef HAVE_SYS_PROCFS_H
7409 # include <sys/procfs.h>
7410 #endif
7411
7412 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
7413
7414 static int
7415 elfcore_make_pid (bfd *abfd)
7416 {
7417   return ((elf_tdata (abfd)->core_lwpid << 16)
7418           + (elf_tdata (abfd)->core_pid));
7419 }
7420
7421 /* If there isn't a section called NAME, make one, using
7422    data from SECT.  Note, this function will generate a
7423    reference to NAME, so you shouldn't deallocate or
7424    overwrite it.  */
7425
7426 static bfd_boolean
7427 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7428 {
7429   asection *sect2;
7430
7431   if (bfd_get_section_by_name (abfd, name) != NULL)
7432     return TRUE;
7433
7434   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7435   if (sect2 == NULL)
7436     return FALSE;
7437
7438   sect2->size = sect->size;
7439   sect2->filepos = sect->filepos;
7440   sect2->alignment_power = sect->alignment_power;
7441   return TRUE;
7442 }
7443
7444 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
7445    actually creates up to two pseudosections:
7446    - For the single-threaded case, a section named NAME, unless
7447      such a section already exists.
7448    - For the multi-threaded case, a section named "NAME/PID", where
7449      PID is elfcore_make_pid (abfd).
7450    Both pseudosections have identical contents. */
7451 bfd_boolean
7452 _bfd_elfcore_make_pseudosection (bfd *abfd,
7453                                  char *name,
7454                                  size_t size,
7455                                  ufile_ptr filepos)
7456 {
7457   char buf[100];
7458   char *threaded_name;
7459   size_t len;
7460   asection *sect;
7461
7462   /* Build the section name.  */
7463
7464   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7465   len = strlen (buf) + 1;
7466   threaded_name = bfd_alloc (abfd, len);
7467   if (threaded_name == NULL)
7468     return FALSE;
7469   memcpy (threaded_name, buf, len);
7470
7471   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7472                                              SEC_HAS_CONTENTS);
7473   if (sect == NULL)
7474     return FALSE;
7475   sect->size = size;
7476   sect->filepos = filepos;
7477   sect->alignment_power = 2;
7478
7479   return elfcore_maybe_make_sect (abfd, name, sect);
7480 }
7481
7482 /* prstatus_t exists on:
7483      solaris 2.5+
7484      linux 2.[01] + glibc
7485      unixware 4.2
7486 */
7487
7488 #if defined (HAVE_PRSTATUS_T)
7489
7490 static bfd_boolean
7491 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7492 {
7493   size_t size;
7494   int offset;
7495
7496   if (note->descsz == sizeof (prstatus_t))
7497     {
7498       prstatus_t prstat;
7499
7500       size = sizeof (prstat.pr_reg);
7501       offset   = offsetof (prstatus_t, pr_reg);
7502       memcpy (&prstat, note->descdata, sizeof (prstat));
7503
7504       /* Do not overwrite the core signal if it
7505          has already been set by another thread.  */
7506       if (elf_tdata (abfd)->core_signal == 0)
7507         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7508       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7509
7510       /* pr_who exists on:
7511          solaris 2.5+
7512          unixware 4.2
7513          pr_who doesn't exist on:
7514          linux 2.[01]
7515          */
7516 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7517       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7518 #endif
7519     }
7520 #if defined (HAVE_PRSTATUS32_T)
7521   else if (note->descsz == sizeof (prstatus32_t))
7522     {
7523       /* 64-bit host, 32-bit corefile */
7524       prstatus32_t prstat;
7525
7526       size = sizeof (prstat.pr_reg);
7527       offset   = offsetof (prstatus32_t, pr_reg);
7528       memcpy (&prstat, note->descdata, sizeof (prstat));
7529
7530       /* Do not overwrite the core signal if it
7531          has already been set by another thread.  */
7532       if (elf_tdata (abfd)->core_signal == 0)
7533         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7534       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7535
7536       /* pr_who exists on:
7537          solaris 2.5+
7538          unixware 4.2
7539          pr_who doesn't exist on:
7540          linux 2.[01]
7541          */
7542 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7543       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7544 #endif
7545     }
7546 #endif /* HAVE_PRSTATUS32_T */
7547   else
7548     {
7549       /* Fail - we don't know how to handle any other
7550          note size (ie. data object type).  */
7551       return TRUE;
7552     }
7553
7554   /* Make a ".reg/999" section and a ".reg" section.  */
7555   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7556                                           size, note->descpos + offset);
7557 }
7558 #endif /* defined (HAVE_PRSTATUS_T) */
7559
7560 /* Create a pseudosection containing the exact contents of NOTE.  */
7561 static bfd_boolean
7562 elfcore_make_note_pseudosection (bfd *abfd,
7563                                  char *name,
7564                                  Elf_Internal_Note *note)
7565 {
7566   return _bfd_elfcore_make_pseudosection (abfd, name,
7567                                           note->descsz, note->descpos);
7568 }
7569
7570 /* There isn't a consistent prfpregset_t across platforms,
7571    but it doesn't matter, because we don't have to pick this
7572    data structure apart.  */
7573
7574 static bfd_boolean
7575 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7576 {
7577   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7578 }
7579
7580 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7581    type of NT_PRXFPREG.  Just include the whole note's contents
7582    literally.  */
7583
7584 static bfd_boolean
7585 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7586 {
7587   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7588 }
7589
7590 static bfd_boolean
7591 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
7592 {
7593   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
7594 }
7595
7596 static bfd_boolean
7597 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
7598 {
7599   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
7600 }
7601
7602 #if defined (HAVE_PRPSINFO_T)
7603 typedef prpsinfo_t   elfcore_psinfo_t;
7604 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
7605 typedef prpsinfo32_t elfcore_psinfo32_t;
7606 #endif
7607 #endif
7608
7609 #if defined (HAVE_PSINFO_T)
7610 typedef psinfo_t   elfcore_psinfo_t;
7611 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
7612 typedef psinfo32_t elfcore_psinfo32_t;
7613 #endif
7614 #endif
7615
7616 /* return a malloc'ed copy of a string at START which is at
7617    most MAX bytes long, possibly without a terminating '\0'.
7618    the copy will always have a terminating '\0'.  */
7619
7620 char *
7621 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7622 {
7623   char *dups;
7624   char *end = memchr (start, '\0', max);
7625   size_t len;
7626
7627   if (end == NULL)
7628     len = max;
7629   else
7630     len = end - start;
7631
7632   dups = bfd_alloc (abfd, len + 1);
7633   if (dups == NULL)
7634     return NULL;
7635
7636   memcpy (dups, start, len);
7637   dups[len] = '\0';
7638
7639   return dups;
7640 }
7641
7642 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7643 static bfd_boolean
7644 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7645 {
7646   if (note->descsz == sizeof (elfcore_psinfo_t))
7647     {
7648       elfcore_psinfo_t psinfo;
7649
7650       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7651
7652       elf_tdata (abfd)->core_program
7653         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7654                                 sizeof (psinfo.pr_fname));
7655
7656       elf_tdata (abfd)->core_command
7657         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7658                                 sizeof (psinfo.pr_psargs));
7659     }
7660 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7661   else if (note->descsz == sizeof (elfcore_psinfo32_t))
7662     {
7663       /* 64-bit host, 32-bit corefile */
7664       elfcore_psinfo32_t psinfo;
7665
7666       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7667
7668       elf_tdata (abfd)->core_program
7669         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7670                                 sizeof (psinfo.pr_fname));
7671
7672       elf_tdata (abfd)->core_command
7673         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7674                                 sizeof (psinfo.pr_psargs));
7675     }
7676 #endif
7677
7678   else
7679     {
7680       /* Fail - we don't know how to handle any other
7681          note size (ie. data object type).  */
7682       return TRUE;
7683     }
7684
7685   /* Note that for some reason, a spurious space is tacked
7686      onto the end of the args in some (at least one anyway)
7687      implementations, so strip it off if it exists.  */
7688
7689   {
7690     char *command = elf_tdata (abfd)->core_command;
7691     int n = strlen (command);
7692
7693     if (0 < n && command[n - 1] == ' ')
7694       command[n - 1] = '\0';
7695   }
7696
7697   return TRUE;
7698 }
7699 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7700
7701 #if defined (HAVE_PSTATUS_T)
7702 static bfd_boolean
7703 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7704 {
7705   if (note->descsz == sizeof (pstatus_t)
7706 #if defined (HAVE_PXSTATUS_T)
7707       || note->descsz == sizeof (pxstatus_t)
7708 #endif
7709       )
7710     {
7711       pstatus_t pstat;
7712
7713       memcpy (&pstat, note->descdata, sizeof (pstat));
7714
7715       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7716     }
7717 #if defined (HAVE_PSTATUS32_T)
7718   else if (note->descsz == sizeof (pstatus32_t))
7719     {
7720       /* 64-bit host, 32-bit corefile */
7721       pstatus32_t pstat;
7722
7723       memcpy (&pstat, note->descdata, sizeof (pstat));
7724
7725       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7726     }
7727 #endif
7728   /* Could grab some more details from the "representative"
7729      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7730      NT_LWPSTATUS note, presumably.  */
7731
7732   return TRUE;
7733 }
7734 #endif /* defined (HAVE_PSTATUS_T) */
7735
7736 #if defined (HAVE_LWPSTATUS_T)
7737 static bfd_boolean
7738 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7739 {
7740   lwpstatus_t lwpstat;
7741   char buf[100];
7742   char *name;
7743   size_t len;
7744   asection *sect;
7745
7746   if (note->descsz != sizeof (lwpstat)
7747 #if defined (HAVE_LWPXSTATUS_T)
7748       && note->descsz != sizeof (lwpxstatus_t)
7749 #endif
7750       )
7751     return TRUE;
7752
7753   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7754
7755   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7756   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7757
7758   /* Make a ".reg/999" section.  */
7759
7760   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7761   len = strlen (buf) + 1;
7762   name = bfd_alloc (abfd, len);
7763   if (name == NULL)
7764     return FALSE;
7765   memcpy (name, buf, len);
7766
7767   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7768   if (sect == NULL)
7769     return FALSE;
7770
7771 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7772   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7773   sect->filepos = note->descpos
7774     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7775 #endif
7776
7777 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7778   sect->size = sizeof (lwpstat.pr_reg);
7779   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7780 #endif
7781
7782   sect->alignment_power = 2;
7783
7784   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7785     return FALSE;
7786
7787   /* Make a ".reg2/999" section */
7788
7789   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7790   len = strlen (buf) + 1;
7791   name = bfd_alloc (abfd, len);
7792   if (name == NULL)
7793     return FALSE;
7794   memcpy (name, buf, len);
7795
7796   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7797   if (sect == NULL)
7798     return FALSE;
7799
7800 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7801   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7802   sect->filepos = note->descpos
7803     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7804 #endif
7805
7806 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7807   sect->size = sizeof (lwpstat.pr_fpreg);
7808   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7809 #endif
7810
7811   sect->alignment_power = 2;
7812
7813   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7814 }
7815 #endif /* defined (HAVE_LWPSTATUS_T) */
7816
7817 static bfd_boolean
7818 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7819 {
7820   char buf[30];
7821   char *name;
7822   size_t len;
7823   asection *sect;
7824   int type;
7825   int is_active_thread;
7826   bfd_vma base_addr;
7827
7828   if (note->descsz < 728)
7829     return TRUE;
7830
7831   if (! CONST_STRNEQ (note->namedata, "win32"))
7832     return TRUE;
7833
7834   type = bfd_get_32 (abfd, note->descdata);
7835
7836   switch (type)
7837     {
7838     case 1 /* NOTE_INFO_PROCESS */:
7839       /* FIXME: need to add ->core_command.  */
7840       /* process_info.pid */
7841       elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
7842       /* process_info.signal */
7843       elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
7844       break;
7845
7846     case 2 /* NOTE_INFO_THREAD */:
7847       /* Make a ".reg/999" section.  */
7848       /* thread_info.tid */
7849       sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
7850
7851       len = strlen (buf) + 1;
7852       name = bfd_alloc (abfd, len);
7853       if (name == NULL)
7854         return FALSE;
7855
7856       memcpy (name, buf, len);
7857
7858       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7859       if (sect == NULL)
7860         return FALSE;
7861
7862       /* sizeof (thread_info.thread_context) */
7863       sect->size = 716;
7864       /* offsetof (thread_info.thread_context) */
7865       sect->filepos = note->descpos + 12;
7866       sect->alignment_power = 2;
7867
7868       /* thread_info.is_active_thread */
7869       is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
7870
7871       if (is_active_thread)
7872         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7873           return FALSE;
7874       break;
7875
7876     case 3 /* NOTE_INFO_MODULE */:
7877       /* Make a ".module/xxxxxxxx" section.  */
7878       /* module_info.base_address */
7879       base_addr = bfd_get_32 (abfd, note->descdata + 4);
7880       sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
7881
7882       len = strlen (buf) + 1;
7883       name = bfd_alloc (abfd, len);
7884       if (name == NULL)
7885         return FALSE;
7886
7887       memcpy (name, buf, len);
7888
7889       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7890
7891       if (sect == NULL)
7892         return FALSE;
7893
7894       sect->size = note->descsz;
7895       sect->filepos = note->descpos;
7896       sect->alignment_power = 2;
7897       break;
7898
7899     default:
7900       return TRUE;
7901     }
7902
7903   return TRUE;
7904 }
7905
7906 static bfd_boolean
7907 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7908 {
7909   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7910
7911   switch (note->type)
7912     {
7913     default:
7914       return TRUE;
7915
7916     case NT_PRSTATUS:
7917       if (bed->elf_backend_grok_prstatus)
7918         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7919           return TRUE;
7920 #if defined (HAVE_PRSTATUS_T)
7921       return elfcore_grok_prstatus (abfd, note);
7922 #else
7923       return TRUE;
7924 #endif
7925
7926 #if defined (HAVE_PSTATUS_T)
7927     case NT_PSTATUS:
7928       return elfcore_grok_pstatus (abfd, note);
7929 #endif
7930
7931 #if defined (HAVE_LWPSTATUS_T)
7932     case NT_LWPSTATUS:
7933       return elfcore_grok_lwpstatus (abfd, note);
7934 #endif
7935
7936     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
7937       return elfcore_grok_prfpreg (abfd, note);
7938
7939     case NT_WIN32PSTATUS:
7940       return elfcore_grok_win32pstatus (abfd, note);
7941
7942     case NT_PRXFPREG:           /* Linux SSE extension */
7943       if (note->namesz == 6
7944           && strcmp (note->namedata, "LINUX") == 0)
7945         return elfcore_grok_prxfpreg (abfd, note);
7946       else
7947         return TRUE;
7948
7949     case NT_PPC_VMX:
7950       if (note->namesz == 6
7951           && strcmp (note->namedata, "LINUX") == 0)
7952         return elfcore_grok_ppc_vmx (abfd, note);
7953       else
7954         return TRUE;
7955
7956     case NT_PPC_VSX:
7957       if (note->namesz == 6
7958           && strcmp (note->namedata, "LINUX") == 0)
7959         return elfcore_grok_ppc_vsx (abfd, note);
7960       else
7961         return TRUE;
7962
7963     case NT_PRPSINFO:
7964     case NT_PSINFO:
7965       if (bed->elf_backend_grok_psinfo)
7966         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7967           return TRUE;
7968 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7969       return elfcore_grok_psinfo (abfd, note);
7970 #else
7971       return TRUE;
7972 #endif
7973
7974     case NT_AUXV:
7975       {
7976         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
7977                                                              SEC_HAS_CONTENTS);
7978
7979         if (sect == NULL)
7980           return FALSE;
7981         sect->size = note->descsz;
7982         sect->filepos = note->descpos;
7983         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7984
7985         return TRUE;
7986       }
7987     }
7988 }
7989
7990 static bfd_boolean
7991 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
7992 {
7993   elf_tdata (abfd)->build_id_size = note->descsz;
7994   elf_tdata (abfd)->build_id = bfd_alloc (abfd, note->descsz);
7995   if (elf_tdata (abfd)->build_id == NULL)
7996     return FALSE;
7997
7998   memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
7999
8000   return TRUE;
8001 }
8002
8003 static bfd_boolean
8004 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8005 {
8006   switch (note->type)
8007     {
8008     default:
8009       return TRUE;
8010
8011     case NT_GNU_BUILD_ID:
8012       return elfobj_grok_gnu_build_id (abfd, note);
8013     }
8014 }
8015
8016 static bfd_boolean
8017 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
8018 {
8019   char *cp;
8020
8021   cp = strchr (note->namedata, '@');
8022   if (cp != NULL)
8023     {
8024       *lwpidp = atoi(cp + 1);
8025       return TRUE;
8026     }
8027   return FALSE;
8028 }
8029
8030 static bfd_boolean
8031 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8032 {
8033   /* Signal number at offset 0x08. */
8034   elf_tdata (abfd)->core_signal
8035     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8036
8037   /* Process ID at offset 0x50. */
8038   elf_tdata (abfd)->core_pid
8039     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8040
8041   /* Command name at 0x7c (max 32 bytes, including nul). */
8042   elf_tdata (abfd)->core_command
8043     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8044
8045   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8046                                           note);
8047 }
8048
8049 static bfd_boolean
8050 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
8051 {
8052   int lwp;
8053
8054   if (elfcore_netbsd_get_lwpid (note, &lwp))
8055     elf_tdata (abfd)->core_lwpid = lwp;
8056
8057   if (note->type == NT_NETBSDCORE_PROCINFO)
8058     {
8059       /* NetBSD-specific core "procinfo".  Note that we expect to
8060          find this note before any of the others, which is fine,
8061          since the kernel writes this note out first when it
8062          creates a core file.  */
8063
8064       return elfcore_grok_netbsd_procinfo (abfd, note);
8065     }
8066
8067   /* As of Jan 2002 there are no other machine-independent notes
8068      defined for NetBSD core files.  If the note type is less
8069      than the start of the machine-dependent note types, we don't
8070      understand it.  */
8071
8072   if (note->type < NT_NETBSDCORE_FIRSTMACH)
8073     return TRUE;
8074
8075
8076   switch (bfd_get_arch (abfd))
8077     {
8078       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8079          PT_GETFPREGS == mach+2.  */
8080
8081     case bfd_arch_alpha:
8082     case bfd_arch_sparc:
8083       switch (note->type)
8084         {
8085         case NT_NETBSDCORE_FIRSTMACH+0:
8086           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8087
8088         case NT_NETBSDCORE_FIRSTMACH+2:
8089           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8090
8091         default:
8092           return TRUE;
8093         }
8094
8095       /* On all other arch's, PT_GETREGS == mach+1 and
8096          PT_GETFPREGS == mach+3.  */
8097
8098     default:
8099       switch (note->type)
8100         {
8101         case NT_NETBSDCORE_FIRSTMACH+1:
8102           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8103
8104         case NT_NETBSDCORE_FIRSTMACH+3:
8105           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8106
8107         default:
8108           return TRUE;
8109         }
8110     }
8111     /* NOTREACHED */
8112 }
8113
8114 static bfd_boolean
8115 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8116 {
8117   void *ddata = note->descdata;
8118   char buf[100];
8119   char *name;
8120   asection *sect;
8121   short sig;
8122   unsigned flags;
8123
8124   /* nto_procfs_status 'pid' field is at offset 0.  */
8125   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8126
8127   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
8128   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8129
8130   /* nto_procfs_status 'flags' field is at offset 8.  */
8131   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8132
8133   /* nto_procfs_status 'what' field is at offset 14.  */
8134   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8135     {
8136       elf_tdata (abfd)->core_signal = sig;
8137       elf_tdata (abfd)->core_lwpid = *tid;
8138     }
8139
8140   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
8141      do not come from signals so we make sure we set the current
8142      thread just in case.  */
8143   if (flags & 0x00000080)
8144     elf_tdata (abfd)->core_lwpid = *tid;
8145
8146   /* Make a ".qnx_core_status/%d" section.  */
8147   sprintf (buf, ".qnx_core_status/%ld", *tid);
8148
8149   name = bfd_alloc (abfd, strlen (buf) + 1);
8150   if (name == NULL)
8151     return FALSE;
8152   strcpy (name, buf);
8153
8154   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8155   if (sect == NULL)
8156     return FALSE;
8157
8158   sect->size            = note->descsz;
8159   sect->filepos         = note->descpos;
8160   sect->alignment_power = 2;
8161
8162   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8163 }
8164
8165 static bfd_boolean
8166 elfcore_grok_nto_regs (bfd *abfd,
8167                        Elf_Internal_Note *note,
8168                        long tid,
8169                        char *base)
8170 {
8171   char buf[100];
8172   char *name;
8173   asection *sect;
8174
8175   /* Make a "(base)/%d" section.  */
8176   sprintf (buf, "%s/%ld", base, tid);
8177
8178   name = bfd_alloc (abfd, strlen (buf) + 1);
8179   if (name == NULL)
8180     return FALSE;
8181   strcpy (name, buf);
8182
8183   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8184   if (sect == NULL)
8185     return FALSE;
8186
8187   sect->size            = note->descsz;
8188   sect->filepos         = note->descpos;
8189   sect->alignment_power = 2;
8190
8191   /* This is the current thread.  */
8192   if (elf_tdata (abfd)->core_lwpid == tid)
8193     return elfcore_maybe_make_sect (abfd, base, sect);
8194
8195   return TRUE;
8196 }
8197
8198 #define BFD_QNT_CORE_INFO       7
8199 #define BFD_QNT_CORE_STATUS     8
8200 #define BFD_QNT_CORE_GREG       9
8201 #define BFD_QNT_CORE_FPREG      10
8202
8203 static bfd_boolean
8204 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8205 {
8206   /* Every GREG section has a STATUS section before it.  Store the
8207      tid from the previous call to pass down to the next gregs
8208      function.  */
8209   static long tid = 1;
8210
8211   switch (note->type)
8212     {
8213     case BFD_QNT_CORE_INFO:
8214       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8215     case BFD_QNT_CORE_STATUS:
8216       return elfcore_grok_nto_status (abfd, note, &tid);
8217     case BFD_QNT_CORE_GREG:
8218       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8219     case BFD_QNT_CORE_FPREG:
8220       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8221     default:
8222       return TRUE;
8223     }
8224 }
8225
8226 static bfd_boolean
8227 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8228 {
8229   char *name;
8230   asection *sect;
8231   size_t len;
8232
8233   /* Use note name as section name.  */
8234   len = note->namesz;
8235   name = bfd_alloc (abfd, len);
8236   if (name == NULL)
8237     return FALSE;
8238   memcpy (name, note->namedata, len);
8239   name[len - 1] = '\0';
8240
8241   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8242   if (sect == NULL)
8243     return FALSE;
8244
8245   sect->size            = note->descsz;
8246   sect->filepos         = note->descpos;
8247   sect->alignment_power = 1;
8248
8249   return TRUE;
8250 }
8251
8252 /* Function: elfcore_write_note
8253
8254    Inputs:
8255      buffer to hold note, and current size of buffer
8256      name of note
8257      type of note
8258      data for note
8259      size of data for note
8260
8261    Writes note to end of buffer.  ELF64 notes are written exactly as
8262    for ELF32, despite the current (as of 2006) ELF gabi specifying
8263    that they ought to have 8-byte namesz and descsz field, and have
8264    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
8265
8266    Return:
8267    Pointer to realloc'd buffer, *BUFSIZ updated.  */
8268
8269 char *
8270 elfcore_write_note (bfd *abfd,
8271                     char *buf,
8272                     int *bufsiz,
8273                     const char *name,
8274                     int type,
8275                     const void *input,
8276                     int size)
8277 {
8278   Elf_External_Note *xnp;
8279   size_t namesz;
8280   size_t newspace;
8281   char *dest;
8282
8283   namesz = 0;
8284   if (name != NULL)
8285     namesz = strlen (name) + 1;
8286
8287   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
8288
8289   buf = realloc (buf, *bufsiz + newspace);
8290   if (buf == NULL)
8291     return buf;
8292   dest = buf + *bufsiz;
8293   *bufsiz += newspace;
8294   xnp = (Elf_External_Note *) dest;
8295   H_PUT_32 (abfd, namesz, xnp->namesz);
8296   H_PUT_32 (abfd, size, xnp->descsz);
8297   H_PUT_32 (abfd, type, xnp->type);
8298   dest = xnp->name;
8299   if (name != NULL)
8300     {
8301       memcpy (dest, name, namesz);
8302       dest += namesz;
8303       while (namesz & 3)
8304         {
8305           *dest++ = '\0';
8306           ++namesz;
8307         }
8308     }
8309   memcpy (dest, input, size);
8310   dest += size;
8311   while (size & 3)
8312     {
8313       *dest++ = '\0';
8314       ++size;
8315     }
8316   return buf;
8317 }
8318
8319 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8320 char *
8321 elfcore_write_prpsinfo (bfd  *abfd,
8322                         char *buf,
8323                         int  *bufsiz,
8324                         const char *fname,
8325                         const char *psargs)
8326 {
8327   const char *note_name = "CORE";
8328   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8329
8330   if (bed->elf_backend_write_core_note != NULL)
8331     {
8332       char *ret;
8333       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8334                                                  NT_PRPSINFO, fname, psargs);
8335       if (ret != NULL)
8336         return ret;
8337     }
8338
8339 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8340   if (bed->s->elfclass == ELFCLASS32)
8341     {
8342 #if defined (HAVE_PSINFO32_T)
8343       psinfo32_t data;
8344       int note_type = NT_PSINFO;
8345 #else
8346       prpsinfo32_t data;
8347       int note_type = NT_PRPSINFO;
8348 #endif
8349
8350       memset (&data, 0, sizeof (data));
8351       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8352       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8353       return elfcore_write_note (abfd, buf, bufsiz,
8354                                  note_name, note_type, &data, sizeof (data));
8355     }
8356   else
8357 #endif
8358     {
8359 #if defined (HAVE_PSINFO_T)
8360       psinfo_t data;
8361       int note_type = NT_PSINFO;
8362 #else
8363       prpsinfo_t data;
8364       int note_type = NT_PRPSINFO;
8365 #endif
8366
8367       memset (&data, 0, sizeof (data));
8368       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8369       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8370       return elfcore_write_note (abfd, buf, bufsiz,
8371                                  note_name, note_type, &data, sizeof (data));
8372     }
8373 }
8374 #endif  /* PSINFO_T or PRPSINFO_T */
8375
8376 #if defined (HAVE_PRSTATUS_T)
8377 char *
8378 elfcore_write_prstatus (bfd *abfd,
8379                         char *buf,
8380                         int *bufsiz,
8381                         long pid,
8382                         int cursig,
8383                         const void *gregs)
8384 {
8385   const char *note_name = "CORE";
8386   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8387
8388   if (bed->elf_backend_write_core_note != NULL)
8389     {
8390       char *ret;
8391       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8392                                                  NT_PRSTATUS,
8393                                                  pid, cursig, gregs);
8394       if (ret != NULL)
8395         return ret;
8396     }
8397
8398 #if defined (HAVE_PRSTATUS32_T)
8399   if (bed->s->elfclass == ELFCLASS32)
8400     {
8401       prstatus32_t prstat;
8402
8403       memset (&prstat, 0, sizeof (prstat));
8404       prstat.pr_pid = pid;
8405       prstat.pr_cursig = cursig;
8406       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8407       return elfcore_write_note (abfd, buf, bufsiz, note_name,
8408                                  NT_PRSTATUS, &prstat, sizeof (prstat));
8409     }
8410   else
8411 #endif
8412     {
8413       prstatus_t prstat;
8414
8415       memset (&prstat, 0, sizeof (prstat));
8416       prstat.pr_pid = pid;
8417       prstat.pr_cursig = cursig;
8418       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8419       return elfcore_write_note (abfd, buf, bufsiz, note_name,
8420                                  NT_PRSTATUS, &prstat, sizeof (prstat));
8421     }
8422 }
8423 #endif /* HAVE_PRSTATUS_T */
8424
8425 #if defined (HAVE_LWPSTATUS_T)
8426 char *
8427 elfcore_write_lwpstatus (bfd *abfd,
8428                          char *buf,
8429                          int *bufsiz,
8430                          long pid,
8431                          int cursig,
8432                          const void *gregs)
8433 {
8434   lwpstatus_t lwpstat;
8435   const char *note_name = "CORE";
8436
8437   memset (&lwpstat, 0, sizeof (lwpstat));
8438   lwpstat.pr_lwpid  = pid >> 16;
8439   lwpstat.pr_cursig = cursig;
8440 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8441   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8442 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8443 #if !defined(gregs)
8444   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8445           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8446 #else
8447   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8448           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8449 #endif
8450 #endif
8451   return elfcore_write_note (abfd, buf, bufsiz, note_name,
8452                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8453 }
8454 #endif /* HAVE_LWPSTATUS_T */
8455
8456 #if defined (HAVE_PSTATUS_T)
8457 char *
8458 elfcore_write_pstatus (bfd *abfd,
8459                        char *buf,
8460                        int *bufsiz,
8461                        long pid,
8462                        int cursig ATTRIBUTE_UNUSED,
8463                        const void *gregs ATTRIBUTE_UNUSED)
8464 {
8465   const char *note_name = "CORE";
8466 #if defined (HAVE_PSTATUS32_T)
8467   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8468
8469   if (bed->s->elfclass == ELFCLASS32)
8470     {
8471       pstatus32_t pstat;
8472
8473       memset (&pstat, 0, sizeof (pstat));
8474       pstat.pr_pid = pid & 0xffff;
8475       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8476                                 NT_PSTATUS, &pstat, sizeof (pstat));
8477       return buf;
8478     }
8479   else
8480 #endif
8481     {
8482       pstatus_t pstat;
8483
8484       memset (&pstat, 0, sizeof (pstat));
8485       pstat.pr_pid = pid & 0xffff;
8486       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8487                                 NT_PSTATUS, &pstat, sizeof (pstat));
8488       return buf;
8489     }
8490 }
8491 #endif /* HAVE_PSTATUS_T */
8492
8493 char *
8494 elfcore_write_prfpreg (bfd *abfd,
8495                        char *buf,
8496                        int *bufsiz,
8497                        const void *fpregs,
8498                        int size)
8499 {
8500   const char *note_name = "CORE";
8501   return elfcore_write_note (abfd, buf, bufsiz,
8502                              note_name, NT_FPREGSET, fpregs, size);
8503 }
8504
8505 char *
8506 elfcore_write_prxfpreg (bfd *abfd,
8507                         char *buf,
8508                         int *bufsiz,
8509                         const void *xfpregs,
8510                         int size)
8511 {
8512   char *note_name = "LINUX";
8513   return elfcore_write_note (abfd, buf, bufsiz,
8514                              note_name, NT_PRXFPREG, xfpregs, size);
8515 }
8516
8517 char *
8518 elfcore_write_ppc_vmx (bfd *abfd,
8519                        char *buf,
8520                        int *bufsiz,
8521                        const void *ppc_vmx,
8522                        int size)
8523 {
8524   char *note_name = "LINUX";
8525   return elfcore_write_note (abfd, buf, bufsiz,
8526                              note_name, NT_PPC_VMX, ppc_vmx, size);
8527 }
8528
8529 char *
8530 elfcore_write_ppc_vsx (bfd *abfd,
8531                        char *buf,
8532                        int *bufsiz,
8533                        const void *ppc_vsx,
8534                        int size)
8535 {
8536   char *note_name = "LINUX";
8537   return elfcore_write_note (abfd, buf, bufsiz,
8538                              note_name, NT_PPC_VSX, ppc_vsx, size);
8539 }
8540
8541 char *
8542 elfcore_write_register_note (bfd *abfd,
8543                              char *buf,
8544                              int *bufsiz,
8545                              const char *section,
8546                              const void *data,
8547                              int size)
8548 {
8549   if (strcmp (section, ".reg2") == 0)
8550     return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
8551   if (strcmp (section, ".reg-xfp") == 0)
8552     return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
8553   if (strcmp (section, ".reg-ppc-vmx") == 0)
8554     return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
8555   if (strcmp (section, ".reg-ppc-vsx") == 0)
8556     return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
8557   return NULL;
8558 }
8559
8560 static bfd_boolean
8561 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
8562 {
8563   char *p;
8564
8565   p = buf;
8566   while (p < buf + size)
8567     {
8568       /* FIXME: bad alignment assumption.  */
8569       Elf_External_Note *xnp = (Elf_External_Note *) p;
8570       Elf_Internal_Note in;
8571
8572       if (offsetof (Elf_External_Note, name) > buf - p + size)
8573         return FALSE;
8574
8575       in.type = H_GET_32 (abfd, xnp->type);
8576
8577       in.namesz = H_GET_32 (abfd, xnp->namesz);
8578       in.namedata = xnp->name;
8579       if (in.namesz > buf - in.namedata + size)
8580         return FALSE;
8581
8582       in.descsz = H_GET_32 (abfd, xnp->descsz);
8583       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8584       in.descpos = offset + (in.descdata - buf);
8585       if (in.descsz != 0
8586           && (in.descdata >= buf + size
8587               || in.descsz > buf - in.descdata + size))
8588         return FALSE;
8589
8590       switch (bfd_get_format (abfd))
8591         {
8592         default:
8593           return TRUE;
8594
8595         case bfd_core:
8596           if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
8597             {
8598               if (! elfcore_grok_netbsd_note (abfd, &in))
8599                 return FALSE;
8600             }
8601           else if (CONST_STRNEQ (in.namedata, "QNX"))
8602             {
8603               if (! elfcore_grok_nto_note (abfd, &in))
8604                 return FALSE;
8605             }
8606           else if (CONST_STRNEQ (in.namedata, "SPU/"))
8607             {
8608               if (! elfcore_grok_spu_note (abfd, &in))
8609                 return FALSE;
8610             }
8611           else
8612             {
8613               if (! elfcore_grok_note (abfd, &in))
8614                 return FALSE;
8615             }
8616           break;
8617
8618         case bfd_object:
8619           if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
8620             {
8621               if (! elfobj_grok_gnu_note (abfd, &in))
8622                 return FALSE;
8623             }
8624           break;
8625         }
8626
8627       p = in.descdata + BFD_ALIGN (in.descsz, 4);
8628     }
8629
8630   return TRUE;
8631 }
8632
8633 static bfd_boolean
8634 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
8635 {
8636   char *buf;
8637
8638   if (size <= 0)
8639     return TRUE;
8640
8641   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
8642     return FALSE;
8643
8644   buf = bfd_malloc (size);
8645   if (buf == NULL)
8646     return FALSE;
8647
8648   if (bfd_bread (buf, size, abfd) != size
8649       || !elf_parse_notes (abfd, buf, size, offset))
8650     {
8651       free (buf);
8652       return FALSE;
8653     }
8654
8655   free (buf);
8656   return TRUE;
8657 }
8658 \f
8659 /* Providing external access to the ELF program header table.  */
8660
8661 /* Return an upper bound on the number of bytes required to store a
8662    copy of ABFD's program header table entries.  Return -1 if an error
8663    occurs; bfd_get_error will return an appropriate code.  */
8664
8665 long
8666 bfd_get_elf_phdr_upper_bound (bfd *abfd)
8667 {
8668   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8669     {
8670       bfd_set_error (bfd_error_wrong_format);
8671       return -1;
8672     }
8673
8674   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
8675 }
8676
8677 /* Copy ABFD's program header table entries to *PHDRS.  The entries
8678    will be stored as an array of Elf_Internal_Phdr structures, as
8679    defined in include/elf/internal.h.  To find out how large the
8680    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8681
8682    Return the number of program header table entries read, or -1 if an
8683    error occurs; bfd_get_error will return an appropriate code.  */
8684
8685 int
8686 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
8687 {
8688   int num_phdrs;
8689
8690   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8691     {
8692       bfd_set_error (bfd_error_wrong_format);
8693       return -1;
8694     }
8695
8696   num_phdrs = elf_elfheader (abfd)->e_phnum;
8697   memcpy (phdrs, elf_tdata (abfd)->phdr,
8698           num_phdrs * sizeof (Elf_Internal_Phdr));
8699
8700   return num_phdrs;
8701 }
8702
8703 enum elf_reloc_type_class
8704 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8705 {
8706   return reloc_class_normal;
8707 }
8708
8709 /* For RELA architectures, return the relocation value for a
8710    relocation against a local symbol.  */
8711
8712 bfd_vma
8713 _bfd_elf_rela_local_sym (bfd *abfd,
8714                          Elf_Internal_Sym *sym,
8715                          asection **psec,
8716                          Elf_Internal_Rela *rel)
8717 {
8718   asection *sec = *psec;
8719   bfd_vma relocation;
8720
8721   relocation = (sec->output_section->vma
8722                 + sec->output_offset
8723                 + sym->st_value);
8724   if ((sec->flags & SEC_MERGE)
8725       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8726       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8727     {
8728       rel->r_addend =
8729         _bfd_merged_section_offset (abfd, psec,
8730                                     elf_section_data (sec)->sec_info,
8731                                     sym->st_value + rel->r_addend);
8732       if (sec != *psec)
8733         {
8734           /* If we have changed the section, and our original section is
8735              marked with SEC_EXCLUDE, it means that the original
8736              SEC_MERGE section has been completely subsumed in some
8737              other SEC_MERGE section.  In this case, we need to leave
8738              some info around for --emit-relocs.  */
8739           if ((sec->flags & SEC_EXCLUDE) != 0)
8740             sec->kept_section = *psec;
8741           sec = *psec;
8742         }
8743       rel->r_addend -= relocation;
8744       rel->r_addend += sec->output_section->vma + sec->output_offset;
8745     }
8746   return relocation;
8747 }
8748
8749 bfd_vma
8750 _bfd_elf_rel_local_sym (bfd *abfd,
8751                         Elf_Internal_Sym *sym,
8752                         asection **psec,
8753                         bfd_vma addend)
8754 {
8755   asection *sec = *psec;
8756
8757   if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8758     return sym->st_value + addend;
8759
8760   return _bfd_merged_section_offset (abfd, psec,
8761                                      elf_section_data (sec)->sec_info,
8762                                      sym->st_value + addend);
8763 }
8764
8765 bfd_vma
8766 _bfd_elf_section_offset (bfd *abfd,
8767                          struct bfd_link_info *info,
8768                          asection *sec,
8769                          bfd_vma offset)
8770 {
8771   switch (sec->sec_info_type)
8772     {
8773     case ELF_INFO_TYPE_STABS:
8774       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8775                                        offset);
8776     case ELF_INFO_TYPE_EH_FRAME:
8777       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8778     default:
8779       return offset;
8780     }
8781 }
8782 \f
8783 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
8784    reconstruct an ELF file by reading the segments out of remote memory
8785    based on the ELF file header at EHDR_VMA and the ELF program headers it
8786    points to.  If not null, *LOADBASEP is filled in with the difference
8787    between the VMAs from which the segments were read, and the VMAs the
8788    file headers (and hence BFD's idea of each section's VMA) put them at.
8789
8790    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8791    remote memory at target address VMA into the local buffer at MYADDR; it
8792    should return zero on success or an `errno' code on failure.  TEMPL must
8793    be a BFD for an ELF target with the word size and byte order found in
8794    the remote memory.  */
8795
8796 bfd *
8797 bfd_elf_bfd_from_remote_memory
8798   (bfd *templ,
8799    bfd_vma ehdr_vma,
8800    bfd_vma *loadbasep,
8801    int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8802 {
8803   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8804     (templ, ehdr_vma, loadbasep, target_read_memory);
8805 }
8806 \f
8807 long
8808 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8809                                long symcount ATTRIBUTE_UNUSED,
8810                                asymbol **syms ATTRIBUTE_UNUSED,
8811                                long dynsymcount,
8812                                asymbol **dynsyms,
8813                                asymbol **ret)
8814 {
8815   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8816   asection *relplt;
8817   asymbol *s;
8818   const char *relplt_name;
8819   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8820   arelent *p;
8821   long count, i, n;
8822   size_t size;
8823   Elf_Internal_Shdr *hdr;
8824   char *names;
8825   asection *plt;
8826
8827   *ret = NULL;
8828
8829   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8830     return 0;
8831
8832   if (dynsymcount <= 0)
8833     return 0;
8834
8835   if (!bed->plt_sym_val)
8836     return 0;
8837
8838   relplt_name = bed->relplt_name;
8839   if (relplt_name == NULL)
8840     relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
8841   relplt = bfd_get_section_by_name (abfd, relplt_name);
8842   if (relplt == NULL)
8843     return 0;
8844
8845   hdr = &elf_section_data (relplt)->this_hdr;
8846   if (hdr->sh_link != elf_dynsymtab (abfd)
8847       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8848     return 0;
8849
8850   plt = bfd_get_section_by_name (abfd, ".plt");
8851   if (plt == NULL)
8852     return 0;
8853
8854   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8855   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8856     return -1;
8857
8858   count = relplt->size / hdr->sh_entsize;
8859   size = count * sizeof (asymbol);
8860   p = relplt->relocation;
8861   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
8862     size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8863
8864   s = *ret = bfd_malloc (size);
8865   if (s == NULL)
8866     return -1;
8867
8868   names = (char *) (s + count);
8869   p = relplt->relocation;
8870   n = 0;
8871   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
8872     {
8873       size_t len;
8874       bfd_vma addr;
8875
8876       addr = bed->plt_sym_val (i, plt, p);
8877       if (addr == (bfd_vma) -1)
8878         continue;
8879
8880       *s = **p->sym_ptr_ptr;
8881       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
8882          we are defining a symbol, ensure one of them is set.  */
8883       if ((s->flags & BSF_LOCAL) == 0)
8884         s->flags |= BSF_GLOBAL;
8885       s->flags |= BSF_SYNTHETIC;
8886       s->section = plt;
8887       s->value = addr - plt->vma;
8888       s->name = names;
8889       s->udata.p = NULL;
8890       len = strlen ((*p->sym_ptr_ptr)->name);
8891       memcpy (names, (*p->sym_ptr_ptr)->name, len);
8892       names += len;
8893       memcpy (names, "@plt", sizeof ("@plt"));
8894       names += sizeof ("@plt");
8895       ++s, ++n;
8896     }
8897
8898   return n;
8899 }
8900
8901 /* It is only used by x86-64 so far.  */
8902 asection _bfd_elf_large_com_section
8903   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
8904                       SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
8905
8906 void
8907 _bfd_elf_set_osabi (bfd * abfd,
8908                     struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
8909 {
8910   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
8911
8912   i_ehdrp = elf_elfheader (abfd);
8913
8914   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
8915 }
8916
8917
8918 /* Return TRUE for ELF symbol types that represent functions.
8919    This is the default version of this function, which is sufficient for
8920    most targets.  It returns true if TYPE is STT_FUNC.  */
8921
8922 bfd_boolean
8923 _bfd_elf_is_function_type (unsigned int type)
8924 {
8925   return (type == STT_FUNC);
8926 }