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.  If the first section isn't loadable, the same
4292              holds for any other sections.  */
4293           i = 0;
4294           while (elf_section_type (m->sections[i]) == SHT_NOBITS)
4295             {
4296               /* If a segment starts with .tbss, we need to look
4297                  at the next section to decide whether the segment
4298                  has any loadable sections.  */
4299               if ((elf_section_flags (m->sections[i]) & SHF_TLS) == 0
4300                   || ++i >= m->count)
4301                 {
4302                   no_contents = TRUE;
4303                   break;
4304                 }
4305             }
4306
4307           off_adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4308           off += off_adjust;
4309           if (no_contents)
4310             {
4311               /* We shouldn't need to align the segment on disk since
4312                  the segment doesn't need file space, but the gABI
4313                  arguably requires the alignment and glibc ld.so
4314                  checks it.  So to comply with the alignment
4315                  requirement but not waste file space, we adjust
4316                  p_offset for just this segment.  (OFF_ADJUST is
4317                  subtracted from OFF later.)  This may put p_offset
4318                  past the end of file, but that shouldn't matter.  */
4319             }
4320           else
4321             off_adjust = 0;
4322         }
4323       /* Make sure the .dynamic section is the first section in the
4324          PT_DYNAMIC segment.  */
4325       else if (p->p_type == PT_DYNAMIC
4326                && m->count > 1
4327                && strcmp (m->sections[0]->name, ".dynamic") != 0)
4328         {
4329           _bfd_error_handler
4330             (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4331              abfd);
4332           bfd_set_error (bfd_error_bad_value);
4333           return FALSE;
4334         }
4335       /* Set the note section type to SHT_NOTE.  */
4336       else if (p->p_type == PT_NOTE)
4337         for (i = 0; i < m->count; i++)
4338           elf_section_type (m->sections[i]) = SHT_NOTE;
4339
4340       p->p_offset = 0;
4341       p->p_filesz = 0;
4342       p->p_memsz = 0;
4343
4344       if (m->includes_filehdr)
4345         {
4346           if (!m->p_flags_valid)
4347             p->p_flags |= PF_R;
4348           p->p_filesz = bed->s->sizeof_ehdr;
4349           p->p_memsz = bed->s->sizeof_ehdr;
4350           if (m->count > 0)
4351             {
4352               BFD_ASSERT (p->p_type == PT_LOAD);
4353
4354               if (p->p_vaddr < (bfd_vma) off)
4355                 {
4356                   (*_bfd_error_handler)
4357                     (_("%B: Not enough room for program headers, try linking with -N"),
4358                      abfd);
4359                   bfd_set_error (bfd_error_bad_value);
4360                   return FALSE;
4361                 }
4362
4363               p->p_vaddr -= off;
4364               if (!m->p_paddr_valid)
4365                 p->p_paddr -= off;
4366             }
4367         }
4368
4369       if (m->includes_phdrs)
4370         {
4371           if (!m->p_flags_valid)
4372             p->p_flags |= PF_R;
4373
4374           if (!m->includes_filehdr)
4375             {
4376               p->p_offset = bed->s->sizeof_ehdr;
4377
4378               if (m->count > 0)
4379                 {
4380                   BFD_ASSERT (p->p_type == PT_LOAD);
4381                   p->p_vaddr -= off - p->p_offset;
4382                   if (!m->p_paddr_valid)
4383                     p->p_paddr -= off - p->p_offset;
4384                 }
4385             }
4386
4387           p->p_filesz += alloc * bed->s->sizeof_phdr;
4388           p->p_memsz += alloc * bed->s->sizeof_phdr;
4389         }
4390
4391       if (p->p_type == PT_LOAD
4392           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4393         {
4394           if (!m->includes_filehdr && !m->includes_phdrs)
4395             p->p_offset = off;
4396           else
4397             {
4398               file_ptr adjust;
4399
4400               adjust = off - (p->p_offset + p->p_filesz);
4401               if (!no_contents)
4402                 p->p_filesz += adjust;
4403               p->p_memsz += adjust;
4404             }
4405         }
4406
4407       /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4408          maps.  Set filepos for sections in PT_LOAD segments, and in
4409          core files, for sections in PT_NOTE segments.
4410          assign_file_positions_for_non_load_sections will set filepos
4411          for other sections and update p_filesz for other segments.  */
4412       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4413         {
4414           asection *sec;
4415           bfd_size_type align;
4416           Elf_Internal_Shdr *this_hdr;
4417
4418           sec = *secpp;
4419           this_hdr = &elf_section_data (sec)->this_hdr;
4420           align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
4421
4422           if ((p->p_type == PT_LOAD
4423                || p->p_type == PT_TLS)
4424               && (this_hdr->sh_type != SHT_NOBITS
4425                   || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4426                       && ((this_hdr->sh_flags & SHF_TLS) == 0
4427                           || p->p_type == PT_TLS))))
4428             {
4429               bfd_signed_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
4430
4431               if (adjust < 0)
4432                 {
4433                   (*_bfd_error_handler)
4434                     (_("%B: section %A vma 0x%lx overlaps previous sections"),
4435                      abfd, sec, (unsigned long) sec->vma);
4436                   adjust = 0;
4437                 }
4438               p->p_memsz += adjust;
4439
4440               if (this_hdr->sh_type != SHT_NOBITS)
4441                 {
4442                   off += adjust;
4443                   p->p_filesz += adjust;
4444                 }
4445             }
4446
4447           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4448             {
4449               /* The section at i == 0 is the one that actually contains
4450                  everything.  */
4451               if (i == 0)
4452                 {
4453                   this_hdr->sh_offset = sec->filepos = off;
4454                   off += this_hdr->sh_size;
4455                   p->p_filesz = this_hdr->sh_size;
4456                   p->p_memsz = 0;
4457                   p->p_align = 1;
4458                 }
4459               else
4460                 {
4461                   /* The rest are fake sections that shouldn't be written.  */
4462                   sec->filepos = 0;
4463                   sec->size = 0;
4464                   sec->flags = 0;
4465                   continue;
4466                 }
4467             }
4468           else
4469             {
4470               if (p->p_type == PT_LOAD)
4471                 {
4472                   this_hdr->sh_offset = sec->filepos = off;
4473                   if (this_hdr->sh_type != SHT_NOBITS)
4474                     off += this_hdr->sh_size;
4475                 }
4476
4477               if (this_hdr->sh_type != SHT_NOBITS)
4478                 {
4479                   p->p_filesz += this_hdr->sh_size;
4480                   /* A load section without SHF_ALLOC is something like
4481                      a note section in a PT_NOTE segment.  These take
4482                      file space but are not loaded into memory.  */
4483                   if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4484                     p->p_memsz += this_hdr->sh_size;
4485                 }
4486               else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4487                 {
4488                   if (p->p_type == PT_TLS)
4489                     p->p_memsz += this_hdr->sh_size;
4490
4491                   /* .tbss is special.  It doesn't contribute to p_memsz of
4492                      normal segments.  */
4493                   else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4494                     p->p_memsz += this_hdr->sh_size;
4495                 }
4496
4497               if (align > p->p_align
4498                   && !m->p_align_valid
4499                   && (p->p_type != PT_LOAD
4500                       || (abfd->flags & D_PAGED) == 0))
4501                 p->p_align = align;
4502             }
4503
4504           if (!m->p_flags_valid)
4505             {
4506               p->p_flags |= PF_R;
4507               if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4508                 p->p_flags |= PF_X;
4509               if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4510                 p->p_flags |= PF_W;
4511             }
4512         }
4513       off -= off_adjust;
4514
4515       /* Check that all sections are in a PT_LOAD segment.
4516          Don't check funky gdb generated core files.  */
4517       if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4518         for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4519           {
4520             Elf_Internal_Shdr *this_hdr;
4521             asection *sec;
4522
4523             sec = *secpp;
4524             this_hdr = &(elf_section_data(sec)->this_hdr);
4525             if (this_hdr->sh_size != 0
4526                 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, p))
4527               {
4528                 (*_bfd_error_handler)
4529                   (_("%B: section `%A' can't be allocated in segment %d"),
4530                    abfd, sec, j);
4531                 print_segment_map (m);
4532                 bfd_set_error (bfd_error_bad_value);
4533                 return FALSE;
4534               }
4535           }
4536     }
4537
4538   elf_tdata (abfd)->next_file_pos = off;
4539   return TRUE;
4540 }
4541
4542 /* Assign file positions for the other sections.  */
4543
4544 static bfd_boolean
4545 assign_file_positions_for_non_load_sections (bfd *abfd,
4546                                              struct bfd_link_info *link_info)
4547 {
4548   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4549   Elf_Internal_Shdr **i_shdrpp;
4550   Elf_Internal_Shdr **hdrpp;
4551   Elf_Internal_Phdr *phdrs;
4552   Elf_Internal_Phdr *p;
4553   struct elf_segment_map *m;
4554   bfd_vma filehdr_vaddr, filehdr_paddr;
4555   bfd_vma phdrs_vaddr, phdrs_paddr;
4556   file_ptr off;
4557   unsigned int num_sec;
4558   unsigned int i;
4559   unsigned int count;
4560
4561   i_shdrpp = elf_elfsections (abfd);
4562   num_sec = elf_numsections (abfd);
4563   off = elf_tdata (abfd)->next_file_pos;
4564   for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4565     {
4566       struct elf_obj_tdata *tdata = elf_tdata (abfd);
4567       Elf_Internal_Shdr *hdr;
4568
4569       hdr = *hdrpp;
4570       if (hdr->bfd_section != NULL
4571           && (hdr->bfd_section->filepos != 0
4572               || (hdr->sh_type == SHT_NOBITS
4573                   && hdr->contents == NULL)))
4574         BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4575       else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4576         {
4577           if (hdr->sh_size != 0)
4578             ((*_bfd_error_handler)
4579              (_("%B: warning: allocated section `%s' not in segment"),
4580               abfd,
4581               (hdr->bfd_section == NULL
4582                ? "*unknown*"
4583                : hdr->bfd_section->name)));
4584           /* We don't need to page align empty sections.  */
4585           if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4586             off += vma_page_aligned_bias (hdr->sh_addr, off,
4587                                           bed->maxpagesize);
4588           else
4589             off += vma_page_aligned_bias (hdr->sh_addr, off,
4590                                           hdr->sh_addralign);
4591           off = _bfd_elf_assign_file_position_for_section (hdr, off,
4592                                                            FALSE);
4593         }
4594       else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4595                 && hdr->bfd_section == NULL)
4596                || hdr == i_shdrpp[tdata->symtab_section]
4597                || hdr == i_shdrpp[tdata->symtab_shndx_section]
4598                || hdr == i_shdrpp[tdata->strtab_section])
4599         hdr->sh_offset = -1;
4600       else
4601         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4602     }
4603
4604   /* Now that we have set the section file positions, we can set up
4605      the file positions for the non PT_LOAD segments.  */
4606   count = 0;
4607   filehdr_vaddr = 0;
4608   filehdr_paddr = 0;
4609   phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4610   phdrs_paddr = 0;
4611   phdrs = elf_tdata (abfd)->phdr;
4612   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4613        m != NULL;
4614        m = m->next, p++)
4615     {
4616       ++count;
4617       if (p->p_type != PT_LOAD)
4618         continue;
4619
4620       if (m->includes_filehdr)
4621         {
4622           filehdr_vaddr = p->p_vaddr;
4623           filehdr_paddr = p->p_paddr;
4624         }
4625       if (m->includes_phdrs)
4626         {
4627           phdrs_vaddr = p->p_vaddr;
4628           phdrs_paddr = p->p_paddr;
4629           if (m->includes_filehdr)
4630             {
4631               phdrs_vaddr += bed->s->sizeof_ehdr;
4632               phdrs_paddr += bed->s->sizeof_ehdr;
4633             }
4634         }
4635     }
4636
4637   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4638        m != NULL;
4639        m = m->next, p++)
4640     {
4641       if (m->count != 0)
4642         {
4643           if (p->p_type != PT_LOAD
4644               && (p->p_type != PT_NOTE
4645                   || bfd_get_format (abfd) != bfd_core))
4646             {
4647               Elf_Internal_Shdr *hdr;
4648               asection *sect;
4649
4650               BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4651
4652               sect = m->sections[m->count - 1];
4653               hdr = &elf_section_data (sect)->this_hdr;
4654               p->p_filesz = sect->filepos - m->sections[0]->filepos;
4655               if (hdr->sh_type != SHT_NOBITS)
4656                 p->p_filesz += hdr->sh_size;
4657
4658               if (p->p_type == PT_GNU_RELRO)
4659                 {
4660                   /* When we get here, we are copying executable
4661                      or shared library. But we need to use the same
4662                      linker logic.  */
4663                   Elf_Internal_Phdr *lp;
4664
4665                   for (lp = phdrs; lp < phdrs + count; ++lp)
4666                     {
4667                       if (lp->p_type == PT_LOAD
4668                           && lp->p_paddr == p->p_paddr)
4669                         break;
4670                     }
4671
4672                   if (lp < phdrs + count)
4673                     {
4674                       /* We should use p_size if it is valid since it
4675                          may contain the first few bytes of the next
4676                          SEC_ALLOC section.  */
4677                       if (m->p_size_valid)
4678                         p->p_filesz = m->p_size;
4679                       else
4680                         abort ();
4681                       p->p_vaddr = lp->p_vaddr;
4682                       p->p_offset = lp->p_offset;
4683                       p->p_memsz = p->p_filesz;
4684                       p->p_align = 1;
4685                     }
4686                   else
4687                     abort ();
4688                 }
4689               else
4690                 p->p_offset = m->sections[0]->filepos;
4691             }
4692         }
4693       else
4694         {
4695           if (m->includes_filehdr)
4696             {
4697               p->p_vaddr = filehdr_vaddr;
4698               if (! m->p_paddr_valid)
4699                 p->p_paddr = filehdr_paddr;
4700             }
4701           else if (m->includes_phdrs)
4702             {
4703               p->p_vaddr = phdrs_vaddr;
4704               if (! m->p_paddr_valid)
4705                 p->p_paddr = phdrs_paddr;
4706             }
4707           else if (p->p_type == PT_GNU_RELRO)
4708             {
4709               Elf_Internal_Phdr *lp;
4710
4711               for (lp = phdrs; lp < phdrs + count; ++lp)
4712                 {
4713                   if (lp->p_type == PT_LOAD
4714                       && lp->p_vaddr <= link_info->relro_end
4715                       && lp->p_vaddr >= link_info->relro_start
4716                       && (lp->p_vaddr + lp->p_filesz
4717                           >= link_info->relro_end))
4718                     break;
4719                 }
4720
4721               if (lp < phdrs + count
4722                   && link_info->relro_end > lp->p_vaddr)
4723                 {
4724                   p->p_vaddr = lp->p_vaddr;
4725                   p->p_paddr = lp->p_paddr;
4726                   p->p_offset = lp->p_offset;
4727                   p->p_filesz = link_info->relro_end - lp->p_vaddr;
4728                   p->p_memsz = p->p_filesz;
4729                   p->p_align = 1;
4730                   p->p_flags = (lp->p_flags & ~PF_W);
4731                 }
4732               else
4733                 {
4734                   memset (p, 0, sizeof *p);
4735                   p->p_type = PT_NULL;
4736                 }
4737             }
4738         }
4739     }
4740
4741   elf_tdata (abfd)->next_file_pos = off;
4742
4743   return TRUE;
4744 }
4745
4746 /* Work out the file positions of all the sections.  This is called by
4747    _bfd_elf_compute_section_file_positions.  All the section sizes and
4748    VMAs must be known before this is called.
4749
4750    Reloc sections come in two flavours: Those processed specially as
4751    "side-channel" data attached to a section to which they apply, and
4752    those that bfd doesn't process as relocations.  The latter sort are
4753    stored in a normal bfd section by bfd_section_from_shdr.   We don't
4754    consider the former sort here, unless they form part of the loadable
4755    image.  Reloc sections not assigned here will be handled later by
4756    assign_file_positions_for_relocs.
4757
4758    We also don't set the positions of the .symtab and .strtab here.  */
4759
4760 static bfd_boolean
4761 assign_file_positions_except_relocs (bfd *abfd,
4762                                      struct bfd_link_info *link_info)
4763 {
4764   struct elf_obj_tdata *tdata = elf_tdata (abfd);
4765   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4766   file_ptr off;
4767   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4768
4769   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4770       && bfd_get_format (abfd) != bfd_core)
4771     {
4772       Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4773       unsigned int num_sec = elf_numsections (abfd);
4774       Elf_Internal_Shdr **hdrpp;
4775       unsigned int i;
4776
4777       /* Start after the ELF header.  */
4778       off = i_ehdrp->e_ehsize;
4779
4780       /* We are not creating an executable, which means that we are
4781          not creating a program header, and that the actual order of
4782          the sections in the file is unimportant.  */
4783       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4784         {
4785           Elf_Internal_Shdr *hdr;
4786
4787           hdr = *hdrpp;
4788           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4789                && hdr->bfd_section == NULL)
4790               || i == tdata->symtab_section
4791               || i == tdata->symtab_shndx_section
4792               || i == tdata->strtab_section)
4793             {
4794               hdr->sh_offset = -1;
4795             }
4796           else
4797             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4798         }
4799     }
4800   else
4801     {
4802       unsigned int alloc;
4803
4804       /* Assign file positions for the loaded sections based on the
4805          assignment of sections to segments.  */
4806       if (!assign_file_positions_for_load_sections (abfd, link_info))
4807         return FALSE;
4808
4809       /* And for non-load sections.  */
4810       if (!assign_file_positions_for_non_load_sections (abfd, link_info))
4811         return FALSE;
4812
4813       if (bed->elf_backend_modify_program_headers != NULL)
4814         {
4815           if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
4816             return FALSE;
4817         }
4818
4819       /* Write out the program headers.  */
4820       alloc = tdata->program_header_size / bed->s->sizeof_phdr;
4821       if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4822           || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
4823         return FALSE;
4824
4825       off = tdata->next_file_pos;
4826     }
4827
4828   /* Place the section headers.  */
4829   off = align_file_position (off, 1 << bed->s->log_file_align);
4830   i_ehdrp->e_shoff = off;
4831   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4832
4833   tdata->next_file_pos = off;
4834
4835   return TRUE;
4836 }
4837
4838 static bfd_boolean
4839 prep_headers (bfd *abfd)
4840 {
4841   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
4842   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4843   struct elf_strtab_hash *shstrtab;
4844   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4845
4846   i_ehdrp = elf_elfheader (abfd);
4847
4848   shstrtab = _bfd_elf_strtab_init ();
4849   if (shstrtab == NULL)
4850     return FALSE;
4851
4852   elf_shstrtab (abfd) = shstrtab;
4853
4854   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4855   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4856   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4857   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4858
4859   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4860   i_ehdrp->e_ident[EI_DATA] =
4861     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4862   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4863
4864   if ((abfd->flags & DYNAMIC) != 0)
4865     i_ehdrp->e_type = ET_DYN;
4866   else if ((abfd->flags & EXEC_P) != 0)
4867     i_ehdrp->e_type = ET_EXEC;
4868   else if (bfd_get_format (abfd) == bfd_core)
4869     i_ehdrp->e_type = ET_CORE;
4870   else
4871     i_ehdrp->e_type = ET_REL;
4872
4873   switch (bfd_get_arch (abfd))
4874     {
4875     case bfd_arch_unknown:
4876       i_ehdrp->e_machine = EM_NONE;
4877       break;
4878
4879       /* There used to be a long list of cases here, each one setting
4880          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4881          in the corresponding bfd definition.  To avoid duplication,
4882          the switch was removed.  Machines that need special handling
4883          can generally do it in elf_backend_final_write_processing(),
4884          unless they need the information earlier than the final write.
4885          Such need can generally be supplied by replacing the tests for
4886          e_machine with the conditions used to determine it.  */
4887     default:
4888       i_ehdrp->e_machine = bed->elf_machine_code;
4889     }
4890
4891   i_ehdrp->e_version = bed->s->ev_current;
4892   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4893
4894   /* No program header, for now.  */
4895   i_ehdrp->e_phoff = 0;
4896   i_ehdrp->e_phentsize = 0;
4897   i_ehdrp->e_phnum = 0;
4898
4899   /* Each bfd section is section header entry.  */
4900   i_ehdrp->e_entry = bfd_get_start_address (abfd);
4901   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4902
4903   /* If we're building an executable, we'll need a program header table.  */
4904   if (abfd->flags & EXEC_P)
4905     /* It all happens later.  */
4906     ;
4907   else
4908     {
4909       i_ehdrp->e_phentsize = 0;
4910       i_phdrp = 0;
4911       i_ehdrp->e_phoff = 0;
4912     }
4913
4914   elf_tdata (abfd)->symtab_hdr.sh_name =
4915     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4916   elf_tdata (abfd)->strtab_hdr.sh_name =
4917     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4918   elf_tdata (abfd)->shstrtab_hdr.sh_name =
4919     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4920   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4921       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4922       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4923     return FALSE;
4924
4925   return TRUE;
4926 }
4927
4928 /* Assign file positions for all the reloc sections which are not part
4929    of the loadable file image.  */
4930
4931 void
4932 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4933 {
4934   file_ptr off;
4935   unsigned int i, num_sec;
4936   Elf_Internal_Shdr **shdrpp;
4937
4938   off = elf_tdata (abfd)->next_file_pos;
4939
4940   num_sec = elf_numsections (abfd);
4941   for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4942     {
4943       Elf_Internal_Shdr *shdrp;
4944
4945       shdrp = *shdrpp;
4946       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4947           && shdrp->sh_offset == -1)
4948         off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4949     }
4950
4951   elf_tdata (abfd)->next_file_pos = off;
4952 }
4953
4954 bfd_boolean
4955 _bfd_elf_write_object_contents (bfd *abfd)
4956 {
4957   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4958   Elf_Internal_Ehdr *i_ehdrp;
4959   Elf_Internal_Shdr **i_shdrp;
4960   bfd_boolean failed;
4961   unsigned int count, num_sec;
4962
4963   if (! abfd->output_has_begun
4964       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4965     return FALSE;
4966
4967   i_shdrp = elf_elfsections (abfd);
4968   i_ehdrp = elf_elfheader (abfd);
4969
4970   failed = FALSE;
4971   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4972   if (failed)
4973     return FALSE;
4974
4975   _bfd_elf_assign_file_positions_for_relocs (abfd);
4976
4977   /* After writing the headers, we need to write the sections too...  */
4978   num_sec = elf_numsections (abfd);
4979   for (count = 1; count < num_sec; count++)
4980     {
4981       if (bed->elf_backend_section_processing)
4982         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4983       if (i_shdrp[count]->contents)
4984         {
4985           bfd_size_type amt = i_shdrp[count]->sh_size;
4986
4987           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4988               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4989             return FALSE;
4990         }
4991     }
4992
4993   /* Write out the section header names.  */
4994   if (elf_shstrtab (abfd) != NULL
4995       && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4996           || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
4997     return FALSE;
4998
4999   if (bed->elf_backend_final_write_processing)
5000     (*bed->elf_backend_final_write_processing) (abfd,
5001                                                 elf_tdata (abfd)->linker);
5002
5003   if (!bed->s->write_shdrs_and_ehdr (abfd))
5004     return FALSE;
5005
5006   /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0].  */
5007   if (elf_tdata (abfd)->after_write_object_contents)
5008     return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
5009
5010   return TRUE;
5011 }
5012
5013 bfd_boolean
5014 _bfd_elf_write_corefile_contents (bfd *abfd)
5015 {
5016   /* Hopefully this can be done just like an object file.  */
5017   return _bfd_elf_write_object_contents (abfd);
5018 }
5019
5020 /* Given a section, search the header to find them.  */
5021
5022 unsigned int
5023 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
5024 {
5025   const struct elf_backend_data *bed;
5026   unsigned int index;
5027
5028   if (elf_section_data (asect) != NULL
5029       && elf_section_data (asect)->this_idx != 0)
5030     return elf_section_data (asect)->this_idx;
5031
5032   if (bfd_is_abs_section (asect))
5033     index = SHN_ABS;
5034   else if (bfd_is_com_section (asect))
5035     index = SHN_COMMON;
5036   else if (bfd_is_und_section (asect))
5037     index = SHN_UNDEF;
5038   else
5039     index = SHN_BAD;
5040
5041   bed = get_elf_backend_data (abfd);
5042   if (bed->elf_backend_section_from_bfd_section)
5043     {
5044       int retval = index;
5045
5046       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5047         return retval;
5048     }
5049
5050   if (index == SHN_BAD)
5051     bfd_set_error (bfd_error_nonrepresentable_section);
5052
5053   return index;
5054 }
5055
5056 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5057    on error.  */
5058
5059 int
5060 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
5061 {
5062   asymbol *asym_ptr = *asym_ptr_ptr;
5063   int idx;
5064   flagword flags = asym_ptr->flags;
5065
5066   /* When gas creates relocations against local labels, it creates its
5067      own symbol for the section, but does put the symbol into the
5068      symbol chain, so udata is 0.  When the linker is generating
5069      relocatable output, this section symbol may be for one of the
5070      input sections rather than the output section.  */
5071   if (asym_ptr->udata.i == 0
5072       && (flags & BSF_SECTION_SYM)
5073       && asym_ptr->section)
5074     {
5075       asection *sec;
5076       int indx;
5077
5078       sec = asym_ptr->section;
5079       if (sec->owner != abfd && sec->output_section != NULL)
5080         sec = sec->output_section;
5081       if (sec->owner == abfd
5082           && (indx = sec->index) < elf_num_section_syms (abfd)
5083           && elf_section_syms (abfd)[indx] != NULL)
5084         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5085     }
5086
5087   idx = asym_ptr->udata.i;
5088
5089   if (idx == 0)
5090     {
5091       /* This case can occur when using --strip-symbol on a symbol
5092          which is used in a relocation entry.  */
5093       (*_bfd_error_handler)
5094         (_("%B: symbol `%s' required but not present"),
5095          abfd, bfd_asymbol_name (asym_ptr));
5096       bfd_set_error (bfd_error_no_symbols);
5097       return -1;
5098     }
5099
5100 #if DEBUG & 4
5101   {
5102     fprintf (stderr,
5103              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5104              (long) asym_ptr, asym_ptr->name, idx, flags,
5105              elf_symbol_flags (flags));
5106     fflush (stderr);
5107   }
5108 #endif
5109
5110   return idx;
5111 }
5112
5113 /* Rewrite program header information.  */
5114
5115 static bfd_boolean
5116 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5117 {
5118   Elf_Internal_Ehdr *iehdr;
5119   struct elf_segment_map *map;
5120   struct elf_segment_map *map_first;
5121   struct elf_segment_map **pointer_to_map;
5122   Elf_Internal_Phdr *segment;
5123   asection *section;
5124   unsigned int i;
5125   unsigned int num_segments;
5126   bfd_boolean phdr_included = FALSE;
5127   bfd_boolean p_paddr_valid;
5128   bfd_vma maxpagesize;
5129   struct elf_segment_map *phdr_adjust_seg = NULL;
5130   unsigned int phdr_adjust_num = 0;
5131   const struct elf_backend_data *bed;
5132
5133   bed = get_elf_backend_data (ibfd);
5134   iehdr = elf_elfheader (ibfd);
5135
5136   map_first = NULL;
5137   pointer_to_map = &map_first;
5138
5139   num_segments = elf_elfheader (ibfd)->e_phnum;
5140   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5141
5142   /* Returns the end address of the segment + 1.  */
5143 #define SEGMENT_END(segment, start)                                     \
5144   (start + (segment->p_memsz > segment->p_filesz                        \
5145             ? segment->p_memsz : segment->p_filesz))
5146
5147 #define SECTION_SIZE(section, segment)                                  \
5148   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
5149     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
5150    ? section->size : 0)
5151
5152   /* Returns TRUE if the given section is contained within
5153      the given segment.  VMA addresses are compared.  */
5154 #define IS_CONTAINED_BY_VMA(section, segment)                           \
5155   (section->vma >= segment->p_vaddr                                     \
5156    && (section->vma + SECTION_SIZE (section, segment)                   \
5157        <= (SEGMENT_END (segment, segment->p_vaddr))))
5158
5159   /* Returns TRUE if the given section is contained within
5160      the given segment.  LMA addresses are compared.  */
5161 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
5162   (section->lma >= base                                                 \
5163    && (section->lma + SECTION_SIZE (section, segment)                   \
5164        <= SEGMENT_END (segment, base)))
5165
5166   /* Handle PT_NOTE segment.  */
5167 #define IS_NOTE(p, s)                                                   \
5168   (p->p_type == PT_NOTE                                                 \
5169    && elf_section_type (s) == SHT_NOTE                                  \
5170    && (bfd_vma) s->filepos >= p->p_offset                               \
5171    && ((bfd_vma) s->filepos + s->size                                   \
5172        <= p->p_offset + p->p_filesz))
5173
5174   /* Special case: corefile "NOTE" section containing regs, prpsinfo
5175      etc.  */
5176 #define IS_COREFILE_NOTE(p, s)                                          \
5177   (IS_NOTE (p, s)                                                       \
5178    && bfd_get_format (ibfd) == bfd_core                                 \
5179    && s->vma == 0                                                       \
5180    && s->lma == 0)
5181
5182   /* The complicated case when p_vaddr is 0 is to handle the Solaris
5183      linker, which generates a PT_INTERP section with p_vaddr and
5184      p_memsz set to 0.  */
5185 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
5186   (p->p_vaddr == 0                                                      \
5187    && p->p_paddr == 0                                                   \
5188    && p->p_memsz == 0                                                   \
5189    && p->p_filesz > 0                                                   \
5190    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
5191    && s->size > 0                                                       \
5192    && (bfd_vma) s->filepos >= p->p_offset                               \
5193    && ((bfd_vma) s->filepos + s->size                                   \
5194        <= p->p_offset + p->p_filesz))
5195
5196   /* Decide if the given section should be included in the given segment.
5197      A section will be included if:
5198        1. It is within the address space of the segment -- we use the LMA
5199           if that is set for the segment and the VMA otherwise,
5200        2. It is an allocated section or a NOTE section in a PT_NOTE
5201           segment.
5202        3. There is an output section associated with it,
5203        4. The section has not already been allocated to a previous segment.
5204        5. PT_GNU_STACK segments do not include any sections.
5205        6. PT_TLS segment includes only SHF_TLS sections.
5206        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5207        8. PT_DYNAMIC should not contain empty sections at the beginning
5208           (with the possible exception of .dynamic).  */
5209 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed)              \
5210   ((((segment->p_paddr                                                  \
5211       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
5212       : IS_CONTAINED_BY_VMA (section, segment))                         \
5213      && (section->flags & SEC_ALLOC) != 0)                              \
5214     || IS_NOTE (segment, section))                                      \
5215    && segment->p_type != PT_GNU_STACK                                   \
5216    && (segment->p_type != PT_TLS                                        \
5217        || (section->flags & SEC_THREAD_LOCAL))                          \
5218    && (segment->p_type == PT_LOAD                                       \
5219        || segment->p_type == PT_TLS                                     \
5220        || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
5221    && (segment->p_type != PT_DYNAMIC                                    \
5222        || SECTION_SIZE (section, segment) > 0                           \
5223        || (segment->p_paddr                                             \
5224            ? segment->p_paddr != section->lma                           \
5225            : segment->p_vaddr != section->vma)                          \
5226        || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic")    \
5227            == 0))                                                       \
5228    && !section->segment_mark)
5229
5230 /* If the output section of a section in the input segment is NULL,
5231    it is removed from the corresponding output segment.   */
5232 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
5233   (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed)          \
5234    && section->output_section != NULL)
5235
5236   /* Returns TRUE iff seg1 starts after the end of seg2.  */
5237 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
5238   (seg1->field >= SEGMENT_END (seg2, seg2->field))
5239
5240   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5241      their VMA address ranges and their LMA address ranges overlap.
5242      It is possible to have overlapping VMA ranges without overlapping LMA
5243      ranges.  RedBoot images for example can have both .data and .bss mapped
5244      to the same VMA range, but with the .data section mapped to a different
5245      LMA.  */
5246 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
5247   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
5248         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
5249    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
5250         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5251
5252   /* Initialise the segment mark field.  */
5253   for (section = ibfd->sections; section != NULL; section = section->next)
5254     section->segment_mark = FALSE;
5255
5256   /* The Solaris linker creates program headers in which all the
5257      p_paddr fields are zero.  When we try to objcopy or strip such a
5258      file, we get confused.  Check for this case, and if we find it
5259      don't set the p_paddr_valid fields.  */
5260   p_paddr_valid = FALSE;
5261   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5262        i < num_segments;
5263        i++, segment++)
5264     if (segment->p_paddr != 0)
5265       {
5266         p_paddr_valid = TRUE;
5267         break;
5268       }
5269
5270   /* Scan through the segments specified in the program header
5271      of the input BFD.  For this first scan we look for overlaps
5272      in the loadable segments.  These can be created by weird
5273      parameters to objcopy.  Also, fix some solaris weirdness.  */
5274   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5275        i < num_segments;
5276        i++, segment++)
5277     {
5278       unsigned int j;
5279       Elf_Internal_Phdr *segment2;
5280
5281       if (segment->p_type == PT_INTERP)
5282         for (section = ibfd->sections; section; section = section->next)
5283           if (IS_SOLARIS_PT_INTERP (segment, section))
5284             {
5285               /* Mininal change so that the normal section to segment
5286                  assignment code will work.  */
5287               segment->p_vaddr = section->vma;
5288               break;
5289             }
5290
5291       if (segment->p_type != PT_LOAD)
5292         {
5293           /* Remove PT_GNU_RELRO segment.  */
5294           if (segment->p_type == PT_GNU_RELRO)
5295             segment->p_type = PT_NULL;
5296           continue;
5297         }
5298
5299       /* Determine if this segment overlaps any previous segments.  */
5300       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
5301         {
5302           bfd_signed_vma extra_length;
5303
5304           if (segment2->p_type != PT_LOAD
5305               || !SEGMENT_OVERLAPS (segment, segment2))
5306             continue;
5307
5308           /* Merge the two segments together.  */
5309           if (segment2->p_vaddr < segment->p_vaddr)
5310             {
5311               /* Extend SEGMENT2 to include SEGMENT and then delete
5312                  SEGMENT.  */
5313               extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5314                               - SEGMENT_END (segment2, segment2->p_vaddr));
5315
5316               if (extra_length > 0)
5317                 {
5318                   segment2->p_memsz += extra_length;
5319                   segment2->p_filesz += extra_length;
5320                 }
5321
5322               segment->p_type = PT_NULL;
5323
5324               /* Since we have deleted P we must restart the outer loop.  */
5325               i = 0;
5326               segment = elf_tdata (ibfd)->phdr;
5327               break;
5328             }
5329           else
5330             {
5331               /* Extend SEGMENT to include SEGMENT2 and then delete
5332                  SEGMENT2.  */
5333               extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5334                               - SEGMENT_END (segment, segment->p_vaddr));
5335
5336               if (extra_length > 0)
5337                 {
5338                   segment->p_memsz += extra_length;
5339                   segment->p_filesz += extra_length;
5340                 }
5341
5342               segment2->p_type = PT_NULL;
5343             }
5344         }
5345     }
5346
5347   /* The second scan attempts to assign sections to segments.  */
5348   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5349        i < num_segments;
5350        i++, segment++)
5351     {
5352       unsigned int section_count;
5353       asection **sections;
5354       asection *output_section;
5355       unsigned int isec;
5356       bfd_vma matching_lma;
5357       bfd_vma suggested_lma;
5358       unsigned int j;
5359       bfd_size_type amt;
5360       asection *first_section;
5361       bfd_boolean first_matching_lma;
5362       bfd_boolean first_suggested_lma;
5363
5364       if (segment->p_type == PT_NULL)
5365         continue;
5366
5367       first_section = NULL;
5368       /* Compute how many sections might be placed into this segment.  */
5369       for (section = ibfd->sections, section_count = 0;
5370            section != NULL;
5371            section = section->next)
5372         {
5373           /* Find the first section in the input segment, which may be
5374              removed from the corresponding output segment.   */
5375           if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5376             {
5377               if (first_section == NULL)
5378                 first_section = section;
5379               if (section->output_section != NULL)
5380                 ++section_count;
5381             }
5382         }
5383
5384       /* Allocate a segment map big enough to contain
5385          all of the sections we have selected.  */
5386       amt = sizeof (struct elf_segment_map);
5387       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5388       map = bfd_zalloc (obfd, amt);
5389       if (map == NULL)
5390         return FALSE;
5391
5392       /* Initialise the fields of the segment map.  Default to
5393          using the physical address of the segment in the input BFD.  */
5394       map->next = NULL;
5395       map->p_type = segment->p_type;
5396       map->p_flags = segment->p_flags;
5397       map->p_flags_valid = 1;
5398
5399       /* If the first section in the input segment is removed, there is
5400          no need to preserve segment physical address in the corresponding
5401          output segment.  */
5402       if (!first_section || first_section->output_section != NULL)
5403         {
5404           map->p_paddr = segment->p_paddr;
5405           map->p_paddr_valid = p_paddr_valid;
5406         }
5407
5408       /* Determine if this segment contains the ELF file header
5409          and if it contains the program headers themselves.  */
5410       map->includes_filehdr = (segment->p_offset == 0
5411                                && segment->p_filesz >= iehdr->e_ehsize);
5412       map->includes_phdrs = 0;
5413
5414       if (!phdr_included || segment->p_type != PT_LOAD)
5415         {
5416           map->includes_phdrs =
5417             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5418              && (segment->p_offset + segment->p_filesz
5419                  >= ((bfd_vma) iehdr->e_phoff
5420                      + iehdr->e_phnum * iehdr->e_phentsize)));
5421
5422           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5423             phdr_included = TRUE;
5424         }
5425
5426       if (section_count == 0)
5427         {
5428           /* Special segments, such as the PT_PHDR segment, may contain
5429              no sections, but ordinary, loadable segments should contain
5430              something.  They are allowed by the ELF spec however, so only
5431              a warning is produced.  */
5432           if (segment->p_type == PT_LOAD)
5433             (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5434                                      " detected, is this intentional ?\n"),
5435                                    ibfd);
5436
5437           map->count = 0;
5438           *pointer_to_map = map;
5439           pointer_to_map = &map->next;
5440
5441           continue;
5442         }
5443
5444       /* Now scan the sections in the input BFD again and attempt
5445          to add their corresponding output sections to the segment map.
5446          The problem here is how to handle an output section which has
5447          been moved (ie had its LMA changed).  There are four possibilities:
5448
5449          1. None of the sections have been moved.
5450             In this case we can continue to use the segment LMA from the
5451             input BFD.
5452
5453          2. All of the sections have been moved by the same amount.
5454             In this case we can change the segment's LMA to match the LMA
5455             of the first section.
5456
5457          3. Some of the sections have been moved, others have not.
5458             In this case those sections which have not been moved can be
5459             placed in the current segment which will have to have its size,
5460             and possibly its LMA changed, and a new segment or segments will
5461             have to be created to contain the other sections.
5462
5463          4. The sections have been moved, but not by the same amount.
5464             In this case we can change the segment's LMA to match the LMA
5465             of the first section and we will have to create a new segment
5466             or segments to contain the other sections.
5467
5468          In order to save time, we allocate an array to hold the section
5469          pointers that we are interested in.  As these sections get assigned
5470          to a segment, they are removed from this array.  */
5471
5472       sections = bfd_malloc2 (section_count, sizeof (asection *));
5473       if (sections == NULL)
5474         return FALSE;
5475
5476       /* Step One: Scan for segment vs section LMA conflicts.
5477          Also add the sections to the section array allocated above.
5478          Also add the sections to the current segment.  In the common
5479          case, where the sections have not been moved, this means that
5480          we have completely filled the segment, and there is nothing
5481          more to do.  */
5482       isec = 0;
5483       matching_lma = 0;
5484       suggested_lma = 0;
5485       first_matching_lma = TRUE;
5486       first_suggested_lma = TRUE;
5487
5488       for (section = ibfd->sections;
5489            section != NULL;
5490            section = section->next)
5491         if (section == first_section)
5492           break;
5493
5494       for (j = 0; section != NULL; section = section->next)
5495         {
5496           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5497             {
5498               output_section = section->output_section;
5499
5500               sections[j++] = section;
5501
5502               /* The Solaris native linker always sets p_paddr to 0.
5503                  We try to catch that case here, and set it to the
5504                  correct value.  Note - some backends require that
5505                  p_paddr be left as zero.  */
5506               if (!p_paddr_valid
5507                   && segment->p_vaddr != 0
5508                   && !bed->want_p_paddr_set_to_zero
5509                   && isec == 0
5510                   && output_section->lma != 0
5511                   && output_section->vma == (segment->p_vaddr
5512                                              + (map->includes_filehdr
5513                                                 ? iehdr->e_ehsize
5514                                                 : 0)
5515                                              + (map->includes_phdrs
5516                                                 ? (iehdr->e_phnum
5517                                                    * iehdr->e_phentsize)
5518                                                 : 0)))
5519                 map->p_paddr = segment->p_vaddr;
5520
5521               /* Match up the physical address of the segment with the
5522                  LMA address of the output section.  */
5523               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5524                   || IS_COREFILE_NOTE (segment, section)
5525                   || (bed->want_p_paddr_set_to_zero
5526                       && IS_CONTAINED_BY_VMA (output_section, segment)))
5527                 {
5528                   if (first_matching_lma || output_section->lma < matching_lma)
5529                     {
5530                       matching_lma = output_section->lma;
5531                       first_matching_lma = FALSE;
5532                     }
5533
5534                   /* We assume that if the section fits within the segment
5535                      then it does not overlap any other section within that
5536                      segment.  */
5537                   map->sections[isec++] = output_section;
5538                 }
5539               else if (first_suggested_lma)
5540                 {
5541                   suggested_lma = output_section->lma;
5542                   first_suggested_lma = FALSE;
5543                 }
5544
5545               if (j == section_count)
5546                 break;
5547             }
5548         }
5549
5550       BFD_ASSERT (j == section_count);
5551
5552       /* Step Two: Adjust the physical address of the current segment,
5553          if necessary.  */
5554       if (isec == section_count)
5555         {
5556           /* All of the sections fitted within the segment as currently
5557              specified.  This is the default case.  Add the segment to
5558              the list of built segments and carry on to process the next
5559              program header in the input BFD.  */
5560           map->count = section_count;
5561           *pointer_to_map = map;
5562           pointer_to_map = &map->next;
5563
5564           if (p_paddr_valid
5565               && !bed->want_p_paddr_set_to_zero
5566               && matching_lma != map->p_paddr
5567               && !map->includes_filehdr
5568               && !map->includes_phdrs)
5569             /* There is some padding before the first section in the
5570                segment.  So, we must account for that in the output
5571                segment's vma.  */
5572             map->p_vaddr_offset = matching_lma - map->p_paddr;
5573
5574           free (sections);
5575           continue;
5576         }
5577       else
5578         {
5579           if (!first_matching_lma)
5580             {
5581               /* At least one section fits inside the current segment.
5582                  Keep it, but modify its physical address to match the
5583                  LMA of the first section that fitted.  */
5584               map->p_paddr = matching_lma;
5585             }
5586           else
5587             {
5588               /* None of the sections fitted inside the current segment.
5589                  Change the current segment's physical address to match
5590                  the LMA of the first section.  */
5591               map->p_paddr = suggested_lma;
5592             }
5593
5594           /* Offset the segment physical address from the lma
5595              to allow for space taken up by elf headers.  */
5596           if (map->includes_filehdr)
5597             {
5598               if (map->p_paddr >= iehdr->e_ehsize)
5599                 map->p_paddr -= iehdr->e_ehsize;
5600               else
5601                 {
5602                   map->includes_filehdr = FALSE;
5603                   map->includes_phdrs = FALSE;
5604                 }
5605             }
5606
5607           if (map->includes_phdrs)
5608             {
5609               if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
5610                 {
5611                   map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5612
5613                   /* iehdr->e_phnum is just an estimate of the number
5614                      of program headers that we will need.  Make a note
5615                      here of the number we used and the segment we chose
5616                      to hold these headers, so that we can adjust the
5617                      offset when we know the correct value.  */
5618                   phdr_adjust_num = iehdr->e_phnum;
5619                   phdr_adjust_seg = map;
5620                 }
5621               else
5622                 map->includes_phdrs = FALSE;
5623             }
5624         }
5625
5626       /* Step Three: Loop over the sections again, this time assigning
5627          those that fit to the current segment and removing them from the
5628          sections array; but making sure not to leave large gaps.  Once all
5629          possible sections have been assigned to the current segment it is
5630          added to the list of built segments and if sections still remain
5631          to be assigned, a new segment is constructed before repeating
5632          the loop.  */
5633       isec = 0;
5634       do
5635         {
5636           map->count = 0;
5637           suggested_lma = 0;
5638           first_suggested_lma = TRUE;
5639
5640           /* Fill the current segment with sections that fit.  */
5641           for (j = 0; j < section_count; j++)
5642             {
5643               section = sections[j];
5644
5645               if (section == NULL)
5646                 continue;
5647
5648               output_section = section->output_section;
5649
5650               BFD_ASSERT (output_section != NULL);
5651
5652               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5653                   || IS_COREFILE_NOTE (segment, section))
5654                 {
5655                   if (map->count == 0)
5656                     {
5657                       /* If the first section in a segment does not start at
5658                          the beginning of the segment, then something is
5659                          wrong.  */
5660                       if (output_section->lma
5661                           != (map->p_paddr
5662                               + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5663                               + (map->includes_phdrs
5664                                  ? iehdr->e_phnum * iehdr->e_phentsize
5665                                  : 0)))
5666                         abort ();
5667                     }
5668                   else
5669                     {
5670                       asection *prev_sec;
5671
5672                       prev_sec = map->sections[map->count - 1];
5673
5674                       /* If the gap between the end of the previous section
5675                          and the start of this section is more than
5676                          maxpagesize then we need to start a new segment.  */
5677                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5678                                       maxpagesize)
5679                            < BFD_ALIGN (output_section->lma, maxpagesize))
5680                           || (prev_sec->lma + prev_sec->size
5681                               > output_section->lma))
5682                         {
5683                           if (first_suggested_lma)
5684                             {
5685                               suggested_lma = output_section->lma;
5686                               first_suggested_lma = FALSE;
5687                             }
5688
5689                           continue;
5690                         }
5691                     }
5692
5693                   map->sections[map->count++] = output_section;
5694                   ++isec;
5695                   sections[j] = NULL;
5696                   section->segment_mark = TRUE;
5697                 }
5698               else if (first_suggested_lma)
5699                 {
5700                   suggested_lma = output_section->lma;
5701                   first_suggested_lma = FALSE;
5702                 }
5703             }
5704
5705           BFD_ASSERT (map->count > 0);
5706
5707           /* Add the current segment to the list of built segments.  */
5708           *pointer_to_map = map;
5709           pointer_to_map = &map->next;
5710
5711           if (isec < section_count)
5712             {
5713               /* We still have not allocated all of the sections to
5714                  segments.  Create a new segment here, initialise it
5715                  and carry on looping.  */
5716               amt = sizeof (struct elf_segment_map);
5717               amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5718               map = bfd_alloc (obfd, amt);
5719               if (map == NULL)
5720                 {
5721                   free (sections);
5722                   return FALSE;
5723                 }
5724
5725               /* Initialise the fields of the segment map.  Set the physical
5726                  physical address to the LMA of the first section that has
5727                  not yet been assigned.  */
5728               map->next = NULL;
5729               map->p_type = segment->p_type;
5730               map->p_flags = segment->p_flags;
5731               map->p_flags_valid = 1;
5732               map->p_paddr = suggested_lma;
5733               map->p_paddr_valid = p_paddr_valid;
5734               map->includes_filehdr = 0;
5735               map->includes_phdrs = 0;
5736             }
5737         }
5738       while (isec < section_count);
5739
5740       free (sections);
5741     }
5742
5743   elf_tdata (obfd)->segment_map = map_first;
5744
5745   /* If we had to estimate the number of program headers that were
5746      going to be needed, then check our estimate now and adjust
5747      the offset if necessary.  */
5748   if (phdr_adjust_seg != NULL)
5749     {
5750       unsigned int count;
5751
5752       for (count = 0, map = map_first; map != NULL; map = map->next)
5753         count++;
5754
5755       if (count > phdr_adjust_num)
5756         phdr_adjust_seg->p_paddr
5757           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5758     }
5759
5760 #undef SEGMENT_END
5761 #undef SECTION_SIZE
5762 #undef IS_CONTAINED_BY_VMA
5763 #undef IS_CONTAINED_BY_LMA
5764 #undef IS_NOTE
5765 #undef IS_COREFILE_NOTE
5766 #undef IS_SOLARIS_PT_INTERP
5767 #undef IS_SECTION_IN_INPUT_SEGMENT
5768 #undef INCLUDE_SECTION_IN_SEGMENT
5769 #undef SEGMENT_AFTER_SEGMENT
5770 #undef SEGMENT_OVERLAPS
5771   return TRUE;
5772 }
5773
5774 /* Copy ELF program header information.  */
5775
5776 static bfd_boolean
5777 copy_elf_program_header (bfd *ibfd, bfd *obfd)
5778 {
5779   Elf_Internal_Ehdr *iehdr;
5780   struct elf_segment_map *map;
5781   struct elf_segment_map *map_first;
5782   struct elf_segment_map **pointer_to_map;
5783   Elf_Internal_Phdr *segment;
5784   unsigned int i;
5785   unsigned int num_segments;
5786   bfd_boolean phdr_included = FALSE;
5787   bfd_boolean p_paddr_valid;
5788
5789   iehdr = elf_elfheader (ibfd);
5790
5791   map_first = NULL;
5792   pointer_to_map = &map_first;
5793
5794   /* If all the segment p_paddr fields are zero, don't set
5795      map->p_paddr_valid.  */
5796   p_paddr_valid = FALSE;
5797   num_segments = elf_elfheader (ibfd)->e_phnum;
5798   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5799        i < num_segments;
5800        i++, segment++)
5801     if (segment->p_paddr != 0)
5802       {
5803         p_paddr_valid = TRUE;
5804         break;
5805       }
5806
5807   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5808        i < num_segments;
5809        i++, segment++)
5810     {
5811       asection *section;
5812       unsigned int section_count;
5813       bfd_size_type amt;
5814       Elf_Internal_Shdr *this_hdr;
5815       asection *first_section = NULL;
5816       asection *lowest_section = NULL;
5817
5818       /* Compute how many sections are in this segment.  */
5819       for (section = ibfd->sections, section_count = 0;
5820            section != NULL;
5821            section = section->next)
5822         {
5823           this_hdr = &(elf_section_data(section)->this_hdr);
5824           if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5825             {
5826               if (!first_section)
5827                 first_section = lowest_section = section;
5828               if (section->lma < lowest_section->lma)
5829                 lowest_section = section;
5830               section_count++;
5831             }
5832         }
5833
5834       /* Allocate a segment map big enough to contain
5835          all of the sections we have selected.  */
5836       amt = sizeof (struct elf_segment_map);
5837       if (section_count != 0)
5838         amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5839       map = bfd_zalloc (obfd, amt);
5840       if (map == NULL)
5841         return FALSE;
5842
5843       /* Initialize the fields of the output segment map with the
5844          input segment.  */
5845       map->next = NULL;
5846       map->p_type = segment->p_type;
5847       map->p_flags = segment->p_flags;
5848       map->p_flags_valid = 1;
5849       map->p_paddr = segment->p_paddr;
5850       map->p_paddr_valid = p_paddr_valid;
5851       map->p_align = segment->p_align;
5852       map->p_align_valid = 1;
5853       map->p_vaddr_offset = 0;
5854
5855       if (map->p_type == PT_GNU_RELRO
5856           && segment->p_filesz == segment->p_memsz)
5857         {
5858           /* The PT_GNU_RELRO segment may contain the first a few
5859              bytes in the .got.plt section even if the whole .got.plt
5860              section isn't in the PT_GNU_RELRO segment.  We won't
5861              change the size of the PT_GNU_RELRO segment.  */
5862           map->p_size = segment->p_filesz;
5863           map->p_size_valid = 1;
5864         }
5865
5866       /* Determine if this segment contains the ELF file header
5867          and if it contains the program headers themselves.  */
5868       map->includes_filehdr = (segment->p_offset == 0
5869                                && segment->p_filesz >= iehdr->e_ehsize);
5870
5871       map->includes_phdrs = 0;
5872       if (! phdr_included || segment->p_type != PT_LOAD)
5873         {
5874           map->includes_phdrs =
5875             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5876              && (segment->p_offset + segment->p_filesz
5877                  >= ((bfd_vma) iehdr->e_phoff
5878                      + iehdr->e_phnum * iehdr->e_phentsize)));
5879
5880           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5881             phdr_included = TRUE;
5882         }
5883
5884       if (!map->includes_phdrs
5885           && !map->includes_filehdr
5886           && map->p_paddr_valid)
5887         /* There is some other padding before the first section.  */
5888         map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
5889                                - segment->p_paddr);
5890
5891       if (section_count != 0)
5892         {
5893           unsigned int isec = 0;
5894
5895           for (section = first_section;
5896                section != NULL;
5897                section = section->next)
5898             {
5899               this_hdr = &(elf_section_data(section)->this_hdr);
5900               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5901                 {
5902                   map->sections[isec++] = section->output_section;
5903                   if (isec == section_count)
5904                     break;
5905                 }
5906             }
5907         }
5908
5909       map->count = section_count;
5910       *pointer_to_map = map;
5911       pointer_to_map = &map->next;
5912     }
5913
5914   elf_tdata (obfd)->segment_map = map_first;
5915   return TRUE;
5916 }
5917
5918 /* Copy private BFD data.  This copies or rewrites ELF program header
5919    information.  */
5920
5921 static bfd_boolean
5922 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5923 {
5924   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5925       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5926     return TRUE;
5927
5928   if (elf_tdata (ibfd)->phdr == NULL)
5929     return TRUE;
5930
5931   if (ibfd->xvec == obfd->xvec)
5932     {
5933       /* Check to see if any sections in the input BFD
5934          covered by ELF program header have changed.  */
5935       Elf_Internal_Phdr *segment;
5936       asection *section, *osec;
5937       unsigned int i, num_segments;
5938       Elf_Internal_Shdr *this_hdr;
5939       const struct elf_backend_data *bed;
5940
5941       bed = get_elf_backend_data (ibfd);
5942
5943       /* Regenerate the segment map if p_paddr is set to 0.  */
5944       if (bed->want_p_paddr_set_to_zero)
5945         goto rewrite;
5946
5947       /* Initialize the segment mark field.  */
5948       for (section = obfd->sections; section != NULL;
5949            section = section->next)
5950         section->segment_mark = FALSE;
5951
5952       num_segments = elf_elfheader (ibfd)->e_phnum;
5953       for (i = 0, segment = elf_tdata (ibfd)->phdr;
5954            i < num_segments;
5955            i++, segment++)
5956         {
5957           /* PR binutils/3535.  The Solaris linker always sets the p_paddr
5958              and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5959              which severly confuses things, so always regenerate the segment
5960              map in this case.  */
5961           if (segment->p_paddr == 0
5962               && segment->p_memsz == 0
5963               && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
5964             goto rewrite;
5965
5966           for (section = ibfd->sections;
5967                section != NULL; section = section->next)
5968             {
5969               /* We mark the output section so that we know it comes
5970                  from the input BFD.  */
5971               osec = section->output_section;
5972               if (osec)
5973                 osec->segment_mark = TRUE;
5974
5975               /* Check if this section is covered by the segment.  */
5976               this_hdr = &(elf_section_data(section)->this_hdr);
5977               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5978                 {
5979                   /* FIXME: Check if its output section is changed or
5980                      removed.  What else do we need to check?  */
5981                   if (osec == NULL
5982                       || section->flags != osec->flags
5983                       || section->lma != osec->lma
5984                       || section->vma != osec->vma
5985                       || section->size != osec->size
5986                       || section->rawsize != osec->rawsize
5987                       || section->alignment_power != osec->alignment_power)
5988                     goto rewrite;
5989                 }
5990             }
5991         }
5992
5993       /* Check to see if any output section do not come from the
5994          input BFD.  */
5995       for (section = obfd->sections; section != NULL;
5996            section = section->next)
5997         {
5998           if (section->segment_mark == FALSE)
5999             goto rewrite;
6000           else
6001             section->segment_mark = FALSE;
6002         }
6003
6004       return copy_elf_program_header (ibfd, obfd);
6005     }
6006
6007 rewrite:
6008   return rewrite_elf_program_header (ibfd, obfd);
6009 }
6010
6011 /* Initialize private output section information from input section.  */
6012
6013 bfd_boolean
6014 _bfd_elf_init_private_section_data (bfd *ibfd,
6015                                     asection *isec,
6016                                     bfd *obfd,
6017                                     asection *osec,
6018                                     struct bfd_link_info *link_info)
6019
6020 {
6021   Elf_Internal_Shdr *ihdr, *ohdr;
6022   bfd_boolean need_group = link_info == NULL || link_info->relocatable;
6023
6024   if (ibfd->xvec->flavour != bfd_target_elf_flavour
6025       || obfd->xvec->flavour != bfd_target_elf_flavour)
6026     return TRUE;
6027
6028   /* Don't copy the output ELF section type from input if the
6029      output BFD section flags have been set to something different.
6030      elf_fake_sections will set ELF section type based on BFD
6031      section flags.  */
6032   if (elf_section_type (osec) == SHT_NULL
6033       && (osec->flags == isec->flags || !osec->flags))
6034     elf_section_type (osec) = elf_section_type (isec);
6035
6036   /* FIXME: Is this correct for all OS/PROC specific flags?  */
6037   elf_section_flags (osec) |= (elf_section_flags (isec)
6038                                & (SHF_MASKOS | SHF_MASKPROC));
6039
6040   /* Set things up for objcopy and relocatable link.  The output
6041      SHT_GROUP section will have its elf_next_in_group pointing back
6042      to the input group members.  Ignore linker created group section.
6043      See elfNN_ia64_object_p in elfxx-ia64.c.  */
6044   if (need_group)
6045     {
6046       if (elf_sec_group (isec) == NULL
6047           || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6048         {
6049           if (elf_section_flags (isec) & SHF_GROUP)
6050             elf_section_flags (osec) |= SHF_GROUP;
6051           elf_next_in_group (osec) = elf_next_in_group (isec);
6052           elf_section_data (osec)->group = elf_section_data (isec)->group;
6053         }
6054     }
6055
6056   ihdr = &elf_section_data (isec)->this_hdr;
6057
6058   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6059      don't use the output section of the linked-to section since it
6060      may be NULL at this point.  */
6061   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6062     {
6063       ohdr = &elf_section_data (osec)->this_hdr;
6064       ohdr->sh_flags |= SHF_LINK_ORDER;
6065       elf_linked_to_section (osec) = elf_linked_to_section (isec);
6066     }
6067
6068   osec->use_rela_p = isec->use_rela_p;
6069
6070   return TRUE;
6071 }
6072
6073 /* Copy private section information.  This copies over the entsize
6074    field, and sometimes the info field.  */
6075
6076 bfd_boolean
6077 _bfd_elf_copy_private_section_data (bfd *ibfd,
6078                                     asection *isec,
6079                                     bfd *obfd,
6080                                     asection *osec)
6081 {
6082   Elf_Internal_Shdr *ihdr, *ohdr;
6083
6084   if (ibfd->xvec->flavour != bfd_target_elf_flavour
6085       || obfd->xvec->flavour != bfd_target_elf_flavour)
6086     return TRUE;
6087
6088   ihdr = &elf_section_data (isec)->this_hdr;
6089   ohdr = &elf_section_data (osec)->this_hdr;
6090
6091   ohdr->sh_entsize = ihdr->sh_entsize;
6092
6093   if (ihdr->sh_type == SHT_SYMTAB
6094       || ihdr->sh_type == SHT_DYNSYM
6095       || ihdr->sh_type == SHT_GNU_verneed
6096       || ihdr->sh_type == SHT_GNU_verdef)
6097     ohdr->sh_info = ihdr->sh_info;
6098
6099   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6100                                              NULL);
6101 }
6102
6103 /* Copy private header information.  */
6104
6105 bfd_boolean
6106 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6107 {
6108   asection *isec;
6109
6110   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6111       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6112     return TRUE;
6113
6114   /* Copy over private BFD data if it has not already been copied.
6115      This must be done here, rather than in the copy_private_bfd_data
6116      entry point, because the latter is called after the section
6117      contents have been set, which means that the program headers have
6118      already been worked out.  */
6119   if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6120     {
6121       if (! copy_private_bfd_data (ibfd, obfd))
6122         return FALSE;
6123     }
6124
6125   /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6126      but this might be wrong if we deleted the group section.  */
6127   for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6128     if (elf_section_type (isec) == SHT_GROUP
6129         && isec->output_section == NULL)
6130       {
6131         asection *first = elf_next_in_group (isec);
6132         asection *s = first;
6133         while (s != NULL)
6134           {
6135             if (s->output_section != NULL)
6136               {
6137                 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6138                 elf_group_name (s->output_section) = NULL;
6139               }
6140             s = elf_next_in_group (s);
6141             if (s == first)
6142               break;
6143           }
6144       }
6145
6146   return TRUE;
6147 }
6148
6149 /* Copy private symbol information.  If this symbol is in a section
6150    which we did not map into a BFD section, try to map the section
6151    index correctly.  We use special macro definitions for the mapped
6152    section indices; these definitions are interpreted by the
6153    swap_out_syms function.  */
6154
6155 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6156 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6157 #define MAP_STRTAB    (SHN_HIOS + 3)
6158 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
6159 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6160
6161 bfd_boolean
6162 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6163                                    asymbol *isymarg,
6164                                    bfd *obfd,
6165                                    asymbol *osymarg)
6166 {
6167   elf_symbol_type *isym, *osym;
6168
6169   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6170       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6171     return TRUE;
6172
6173   isym = elf_symbol_from (ibfd, isymarg);
6174   osym = elf_symbol_from (obfd, osymarg);
6175
6176   if (isym != NULL
6177       && isym->internal_elf_sym.st_shndx != 0
6178       && osym != NULL
6179       && bfd_is_abs_section (isym->symbol.section))
6180     {
6181       unsigned int shndx;
6182
6183       shndx = isym->internal_elf_sym.st_shndx;
6184       if (shndx == elf_onesymtab (ibfd))
6185         shndx = MAP_ONESYMTAB;
6186       else if (shndx == elf_dynsymtab (ibfd))
6187         shndx = MAP_DYNSYMTAB;
6188       else if (shndx == elf_tdata (ibfd)->strtab_section)
6189         shndx = MAP_STRTAB;
6190       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6191         shndx = MAP_SHSTRTAB;
6192       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6193         shndx = MAP_SYM_SHNDX;
6194       osym->internal_elf_sym.st_shndx = shndx;
6195     }
6196
6197   return TRUE;
6198 }
6199
6200 /* Swap out the symbols.  */
6201
6202 static bfd_boolean
6203 swap_out_syms (bfd *abfd,
6204                struct bfd_strtab_hash **sttp,
6205                int relocatable_p)
6206 {
6207   const struct elf_backend_data *bed;
6208   int symcount;
6209   asymbol **syms;
6210   struct bfd_strtab_hash *stt;
6211   Elf_Internal_Shdr *symtab_hdr;
6212   Elf_Internal_Shdr *symtab_shndx_hdr;
6213   Elf_Internal_Shdr *symstrtab_hdr;
6214   bfd_byte *outbound_syms;
6215   bfd_byte *outbound_shndx;
6216   int idx;
6217   bfd_size_type amt;
6218   bfd_boolean name_local_sections;
6219
6220   if (!elf_map_symbols (abfd))
6221     return FALSE;
6222
6223   /* Dump out the symtabs.  */
6224   stt = _bfd_elf_stringtab_init ();
6225   if (stt == NULL)
6226     return FALSE;
6227
6228   bed = get_elf_backend_data (abfd);
6229   symcount = bfd_get_symcount (abfd);
6230   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6231   symtab_hdr->sh_type = SHT_SYMTAB;
6232   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6233   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6234   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6235   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
6236
6237   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6238   symstrtab_hdr->sh_type = SHT_STRTAB;
6239
6240   outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
6241   if (outbound_syms == NULL)
6242     {
6243       _bfd_stringtab_free (stt);
6244       return FALSE;
6245     }
6246   symtab_hdr->contents = outbound_syms;
6247
6248   outbound_shndx = NULL;
6249   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6250   if (symtab_shndx_hdr->sh_name != 0)
6251     {
6252       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6253       outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
6254                                     sizeof (Elf_External_Sym_Shndx));
6255       if (outbound_shndx == NULL)
6256         {
6257           _bfd_stringtab_free (stt);
6258           return FALSE;
6259         }
6260
6261       symtab_shndx_hdr->contents = outbound_shndx;
6262       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6263       symtab_shndx_hdr->sh_size = amt;
6264       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6265       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6266     }
6267
6268   /* Now generate the data (for "contents").  */
6269   {
6270     /* Fill in zeroth symbol and swap it out.  */
6271     Elf_Internal_Sym sym;
6272     sym.st_name = 0;
6273     sym.st_value = 0;
6274     sym.st_size = 0;
6275     sym.st_info = 0;
6276     sym.st_other = 0;
6277     sym.st_shndx = SHN_UNDEF;
6278     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6279     outbound_syms += bed->s->sizeof_sym;
6280     if (outbound_shndx != NULL)
6281       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6282   }
6283
6284   name_local_sections
6285     = (bed->elf_backend_name_local_section_symbols
6286        && bed->elf_backend_name_local_section_symbols (abfd));
6287
6288   syms = bfd_get_outsymbols (abfd);
6289   for (idx = 0; idx < symcount; idx++)
6290     {
6291       Elf_Internal_Sym sym;
6292       bfd_vma value = syms[idx]->value;
6293       elf_symbol_type *type_ptr;
6294       flagword flags = syms[idx]->flags;
6295       int type;
6296
6297       if (!name_local_sections
6298           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6299         {
6300           /* Local section symbols have no name.  */
6301           sym.st_name = 0;
6302         }
6303       else
6304         {
6305           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6306                                                             syms[idx]->name,
6307                                                             TRUE, FALSE);
6308           if (sym.st_name == (unsigned long) -1)
6309             {
6310               _bfd_stringtab_free (stt);
6311               return FALSE;
6312             }
6313         }
6314
6315       type_ptr = elf_symbol_from (abfd, syms[idx]);
6316
6317       if ((flags & BSF_SECTION_SYM) == 0
6318           && bfd_is_com_section (syms[idx]->section))
6319         {
6320           /* ELF common symbols put the alignment into the `value' field,
6321              and the size into the `size' field.  This is backwards from
6322              how BFD handles it, so reverse it here.  */
6323           sym.st_size = value;
6324           if (type_ptr == NULL
6325               || type_ptr->internal_elf_sym.st_value == 0)
6326             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6327           else
6328             sym.st_value = type_ptr->internal_elf_sym.st_value;
6329           sym.st_shndx = _bfd_elf_section_from_bfd_section
6330             (abfd, syms[idx]->section);
6331         }
6332       else
6333         {
6334           asection *sec = syms[idx]->section;
6335           unsigned int shndx;
6336
6337           if (sec->output_section)
6338             {
6339               value += sec->output_offset;
6340               sec = sec->output_section;
6341             }
6342
6343           /* Don't add in the section vma for relocatable output.  */
6344           if (! relocatable_p)
6345             value += sec->vma;
6346           sym.st_value = value;
6347           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6348
6349           if (bfd_is_abs_section (sec)
6350               && type_ptr != NULL
6351               && type_ptr->internal_elf_sym.st_shndx != 0)
6352             {
6353               /* This symbol is in a real ELF section which we did
6354                  not create as a BFD section.  Undo the mapping done
6355                  by copy_private_symbol_data.  */
6356               shndx = type_ptr->internal_elf_sym.st_shndx;
6357               switch (shndx)
6358                 {
6359                 case MAP_ONESYMTAB:
6360                   shndx = elf_onesymtab (abfd);
6361                   break;
6362                 case MAP_DYNSYMTAB:
6363                   shndx = elf_dynsymtab (abfd);
6364                   break;
6365                 case MAP_STRTAB:
6366                   shndx = elf_tdata (abfd)->strtab_section;
6367                   break;
6368                 case MAP_SHSTRTAB:
6369                   shndx = elf_tdata (abfd)->shstrtab_section;
6370                   break;
6371                 case MAP_SYM_SHNDX:
6372                   shndx = elf_tdata (abfd)->symtab_shndx_section;
6373                   break;
6374                 default:
6375                   break;
6376                 }
6377             }
6378           else
6379             {
6380               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6381
6382               if (shndx == SHN_BAD)
6383                 {
6384                   asection *sec2;
6385
6386                   /* Writing this would be a hell of a lot easier if
6387                      we had some decent documentation on bfd, and
6388                      knew what to expect of the library, and what to
6389                      demand of applications.  For example, it
6390                      appears that `objcopy' might not set the
6391                      section of a symbol to be a section that is
6392                      actually in the output file.  */
6393                   sec2 = bfd_get_section_by_name (abfd, sec->name);
6394                   if (sec2 == NULL)
6395                     {
6396                       _bfd_error_handler (_("\
6397 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6398                                           syms[idx]->name ? syms[idx]->name : "<Local sym>",
6399                                           sec->name);
6400                       bfd_set_error (bfd_error_invalid_operation);
6401                       _bfd_stringtab_free (stt);
6402                       return FALSE;
6403                     }
6404
6405                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6406                   BFD_ASSERT (shndx != SHN_BAD);
6407                 }
6408             }
6409
6410           sym.st_shndx = shndx;
6411         }
6412
6413       if ((flags & BSF_THREAD_LOCAL) != 0)
6414         type = STT_TLS;
6415       else if ((flags & BSF_FUNCTION) != 0)
6416         type = STT_FUNC;
6417       else if ((flags & BSF_OBJECT) != 0)
6418         type = STT_OBJECT;
6419       else if ((flags & BSF_RELC) != 0)
6420         type = STT_RELC;
6421       else if ((flags & BSF_SRELC) != 0)
6422         type = STT_SRELC;
6423       else
6424         type = STT_NOTYPE;
6425
6426       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6427         type = STT_TLS;
6428
6429       /* Processor-specific types.  */
6430       if (type_ptr != NULL
6431           && bed->elf_backend_get_symbol_type)
6432         type = ((*bed->elf_backend_get_symbol_type)
6433                 (&type_ptr->internal_elf_sym, type));
6434
6435       if (flags & BSF_SECTION_SYM)
6436         {
6437           if (flags & BSF_GLOBAL)
6438             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6439           else
6440             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6441         }
6442       else if (bfd_is_com_section (syms[idx]->section))
6443         {
6444 #ifdef USE_STT_COMMON
6445           if (type == STT_OBJECT)
6446             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6447           else
6448 #else
6449             sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6450 #endif
6451         }
6452       else if (bfd_is_und_section (syms[idx]->section))
6453         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6454                                     ? STB_WEAK
6455                                     : STB_GLOBAL),
6456                                    type);
6457       else if (flags & BSF_FILE)
6458         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6459       else
6460         {
6461           int bind = STB_LOCAL;
6462
6463           if (flags & BSF_LOCAL)
6464             bind = STB_LOCAL;
6465           else if (flags & BSF_WEAK)
6466             bind = STB_WEAK;
6467           else if (flags & BSF_GLOBAL)
6468             bind = STB_GLOBAL;
6469
6470           sym.st_info = ELF_ST_INFO (bind, type);
6471         }
6472
6473       if (type_ptr != NULL)
6474         sym.st_other = type_ptr->internal_elf_sym.st_other;
6475       else
6476         sym.st_other = 0;
6477
6478       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6479       outbound_syms += bed->s->sizeof_sym;
6480       if (outbound_shndx != NULL)
6481         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6482     }
6483
6484   *sttp = stt;
6485   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6486   symstrtab_hdr->sh_type = SHT_STRTAB;
6487
6488   symstrtab_hdr->sh_flags = 0;
6489   symstrtab_hdr->sh_addr = 0;
6490   symstrtab_hdr->sh_entsize = 0;
6491   symstrtab_hdr->sh_link = 0;
6492   symstrtab_hdr->sh_info = 0;
6493   symstrtab_hdr->sh_addralign = 1;
6494
6495   return TRUE;
6496 }
6497
6498 /* Return the number of bytes required to hold the symtab vector.
6499
6500    Note that we base it on the count plus 1, since we will null terminate
6501    the vector allocated based on this size.  However, the ELF symbol table
6502    always has a dummy entry as symbol #0, so it ends up even.  */
6503
6504 long
6505 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6506 {
6507   long symcount;
6508   long symtab_size;
6509   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6510
6511   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6512   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6513   if (symcount > 0)
6514     symtab_size -= sizeof (asymbol *);
6515
6516   return symtab_size;
6517 }
6518
6519 long
6520 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6521 {
6522   long symcount;
6523   long symtab_size;
6524   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6525
6526   if (elf_dynsymtab (abfd) == 0)
6527     {
6528       bfd_set_error (bfd_error_invalid_operation);
6529       return -1;
6530     }
6531
6532   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6533   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6534   if (symcount > 0)
6535     symtab_size -= sizeof (asymbol *);
6536
6537   return symtab_size;
6538 }
6539
6540 long
6541 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6542                                 sec_ptr asect)
6543 {
6544   return (asect->reloc_count + 1) * sizeof (arelent *);
6545 }
6546
6547 /* Canonicalize the relocs.  */
6548
6549 long
6550 _bfd_elf_canonicalize_reloc (bfd *abfd,
6551                              sec_ptr section,
6552                              arelent **relptr,
6553                              asymbol **symbols)
6554 {
6555   arelent *tblptr;
6556   unsigned int i;
6557   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6558
6559   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6560     return -1;
6561
6562   tblptr = section->relocation;
6563   for (i = 0; i < section->reloc_count; i++)
6564     *relptr++ = tblptr++;
6565
6566   *relptr = NULL;
6567
6568   return section->reloc_count;
6569 }
6570
6571 long
6572 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6573 {
6574   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6575   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6576
6577   if (symcount >= 0)
6578     bfd_get_symcount (abfd) = symcount;
6579   return symcount;
6580 }
6581
6582 long
6583 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6584                                       asymbol **allocation)
6585 {
6586   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6587   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6588
6589   if (symcount >= 0)
6590     bfd_get_dynamic_symcount (abfd) = symcount;
6591   return symcount;
6592 }
6593
6594 /* Return the size required for the dynamic reloc entries.  Any loadable
6595    section that was actually installed in the BFD, and has type SHT_REL
6596    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6597    dynamic reloc section.  */
6598
6599 long
6600 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6601 {
6602   long ret;
6603   asection *s;
6604
6605   if (elf_dynsymtab (abfd) == 0)
6606     {
6607       bfd_set_error (bfd_error_invalid_operation);
6608       return -1;
6609     }
6610
6611   ret = sizeof (arelent *);
6612   for (s = abfd->sections; s != NULL; s = s->next)
6613     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6614         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6615             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6616       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6617               * sizeof (arelent *));
6618
6619   return ret;
6620 }
6621
6622 /* Canonicalize the dynamic relocation entries.  Note that we return the
6623    dynamic relocations as a single block, although they are actually
6624    associated with particular sections; the interface, which was
6625    designed for SunOS style shared libraries, expects that there is only
6626    one set of dynamic relocs.  Any loadable section that was actually
6627    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6628    dynamic symbol table, is considered to be a dynamic reloc section.  */
6629
6630 long
6631 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6632                                      arelent **storage,
6633                                      asymbol **syms)
6634 {
6635   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6636   asection *s;
6637   long ret;
6638
6639   if (elf_dynsymtab (abfd) == 0)
6640     {
6641       bfd_set_error (bfd_error_invalid_operation);
6642       return -1;
6643     }
6644
6645   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6646   ret = 0;
6647   for (s = abfd->sections; s != NULL; s = s->next)
6648     {
6649       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6650           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6651               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6652         {
6653           arelent *p;
6654           long count, i;
6655
6656           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6657             return -1;
6658           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6659           p = s->relocation;
6660           for (i = 0; i < count; i++)
6661             *storage++ = p++;
6662           ret += count;
6663         }
6664     }
6665
6666   *storage = NULL;
6667
6668   return ret;
6669 }
6670 \f
6671 /* Read in the version information.  */
6672
6673 bfd_boolean
6674 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6675 {
6676   bfd_byte *contents = NULL;
6677   unsigned int freeidx = 0;
6678
6679   if (elf_dynverref (abfd) != 0)
6680     {
6681       Elf_Internal_Shdr *hdr;
6682       Elf_External_Verneed *everneed;
6683       Elf_Internal_Verneed *iverneed;
6684       unsigned int i;
6685       bfd_byte *contents_end;
6686
6687       hdr = &elf_tdata (abfd)->dynverref_hdr;
6688
6689       elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6690                                               sizeof (Elf_Internal_Verneed));
6691       if (elf_tdata (abfd)->verref == NULL)
6692         goto error_return;
6693
6694       elf_tdata (abfd)->cverrefs = hdr->sh_info;
6695
6696       contents = bfd_malloc (hdr->sh_size);
6697       if (contents == NULL)
6698         {
6699 error_return_verref:
6700           elf_tdata (abfd)->verref = NULL;
6701           elf_tdata (abfd)->cverrefs = 0;
6702           goto error_return;
6703         }
6704       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6705           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6706         goto error_return_verref;
6707
6708       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6709         goto error_return_verref;
6710
6711       BFD_ASSERT (sizeof (Elf_External_Verneed)
6712                   == sizeof (Elf_External_Vernaux));
6713       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6714       everneed = (Elf_External_Verneed *) contents;
6715       iverneed = elf_tdata (abfd)->verref;
6716       for (i = 0; i < hdr->sh_info; i++, iverneed++)
6717         {
6718           Elf_External_Vernaux *evernaux;
6719           Elf_Internal_Vernaux *ivernaux;
6720           unsigned int j;
6721
6722           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6723
6724           iverneed->vn_bfd = abfd;
6725
6726           iverneed->vn_filename =
6727             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6728                                              iverneed->vn_file);
6729           if (iverneed->vn_filename == NULL)
6730             goto error_return_verref;
6731
6732           if (iverneed->vn_cnt == 0)
6733             iverneed->vn_auxptr = NULL;
6734           else
6735             {
6736               iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6737                                                 sizeof (Elf_Internal_Vernaux));
6738               if (iverneed->vn_auxptr == NULL)
6739                 goto error_return_verref;
6740             }
6741
6742           if (iverneed->vn_aux
6743               > (size_t) (contents_end - (bfd_byte *) everneed))
6744             goto error_return_verref;
6745
6746           evernaux = ((Elf_External_Vernaux *)
6747                       ((bfd_byte *) everneed + iverneed->vn_aux));
6748           ivernaux = iverneed->vn_auxptr;
6749           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6750             {
6751               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6752
6753               ivernaux->vna_nodename =
6754                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6755                                                  ivernaux->vna_name);
6756               if (ivernaux->vna_nodename == NULL)
6757                 goto error_return_verref;
6758
6759               if (j + 1 < iverneed->vn_cnt)
6760                 ivernaux->vna_nextptr = ivernaux + 1;
6761               else
6762                 ivernaux->vna_nextptr = NULL;
6763
6764               if (ivernaux->vna_next
6765                   > (size_t) (contents_end - (bfd_byte *) evernaux))
6766                 goto error_return_verref;
6767
6768               evernaux = ((Elf_External_Vernaux *)
6769                           ((bfd_byte *) evernaux + ivernaux->vna_next));
6770
6771               if (ivernaux->vna_other > freeidx)
6772                 freeidx = ivernaux->vna_other;
6773             }
6774
6775           if (i + 1 < hdr->sh_info)
6776             iverneed->vn_nextref = iverneed + 1;
6777           else
6778             iverneed->vn_nextref = NULL;
6779
6780           if (iverneed->vn_next
6781               > (size_t) (contents_end - (bfd_byte *) everneed))
6782             goto error_return_verref;
6783
6784           everneed = ((Elf_External_Verneed *)
6785                       ((bfd_byte *) everneed + iverneed->vn_next));
6786         }
6787
6788       free (contents);
6789       contents = NULL;
6790     }
6791
6792   if (elf_dynverdef (abfd) != 0)
6793     {
6794       Elf_Internal_Shdr *hdr;
6795       Elf_External_Verdef *everdef;
6796       Elf_Internal_Verdef *iverdef;
6797       Elf_Internal_Verdef *iverdefarr;
6798       Elf_Internal_Verdef iverdefmem;
6799       unsigned int i;
6800       unsigned int maxidx;
6801       bfd_byte *contents_end_def, *contents_end_aux;
6802
6803       hdr = &elf_tdata (abfd)->dynverdef_hdr;
6804
6805       contents = bfd_malloc (hdr->sh_size);
6806       if (contents == NULL)
6807         goto error_return;
6808       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6809           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6810         goto error_return;
6811
6812       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6813         goto error_return;
6814
6815       BFD_ASSERT (sizeof (Elf_External_Verdef)
6816                   >= sizeof (Elf_External_Verdaux));
6817       contents_end_def = contents + hdr->sh_size
6818                          - sizeof (Elf_External_Verdef);
6819       contents_end_aux = contents + hdr->sh_size
6820                          - sizeof (Elf_External_Verdaux);
6821
6822       /* We know the number of entries in the section but not the maximum
6823          index.  Therefore we have to run through all entries and find
6824          the maximum.  */
6825       everdef = (Elf_External_Verdef *) contents;
6826       maxidx = 0;
6827       for (i = 0; i < hdr->sh_info; ++i)
6828         {
6829           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6830
6831           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6832             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6833
6834           if (iverdefmem.vd_next
6835               > (size_t) (contents_end_def - (bfd_byte *) everdef))
6836             goto error_return;
6837
6838           everdef = ((Elf_External_Verdef *)
6839                      ((bfd_byte *) everdef + iverdefmem.vd_next));
6840         }
6841
6842       if (default_imported_symver)
6843         {
6844           if (freeidx > maxidx)
6845             maxidx = ++freeidx;
6846           else
6847             freeidx = ++maxidx;
6848         }
6849       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6850                                               sizeof (Elf_Internal_Verdef));
6851       if (elf_tdata (abfd)->verdef == NULL)
6852         goto error_return;
6853
6854       elf_tdata (abfd)->cverdefs = maxidx;
6855
6856       everdef = (Elf_External_Verdef *) contents;
6857       iverdefarr = elf_tdata (abfd)->verdef;
6858       for (i = 0; i < hdr->sh_info; i++)
6859         {
6860           Elf_External_Verdaux *everdaux;
6861           Elf_Internal_Verdaux *iverdaux;
6862           unsigned int j;
6863
6864           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6865
6866           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6867             {
6868 error_return_verdef:
6869               elf_tdata (abfd)->verdef = NULL;
6870               elf_tdata (abfd)->cverdefs = 0;
6871               goto error_return;
6872             }
6873
6874           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6875           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6876
6877           iverdef->vd_bfd = abfd;
6878
6879           if (iverdef->vd_cnt == 0)
6880             iverdef->vd_auxptr = NULL;
6881           else
6882             {
6883               iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6884                                                sizeof (Elf_Internal_Verdaux));
6885               if (iverdef->vd_auxptr == NULL)
6886                 goto error_return_verdef;
6887             }
6888
6889           if (iverdef->vd_aux
6890               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6891             goto error_return_verdef;
6892
6893           everdaux = ((Elf_External_Verdaux *)
6894                       ((bfd_byte *) everdef + iverdef->vd_aux));
6895           iverdaux = iverdef->vd_auxptr;
6896           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6897             {
6898               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6899
6900               iverdaux->vda_nodename =
6901                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6902                                                  iverdaux->vda_name);
6903               if (iverdaux->vda_nodename == NULL)
6904                 goto error_return_verdef;
6905
6906               if (j + 1 < iverdef->vd_cnt)
6907                 iverdaux->vda_nextptr = iverdaux + 1;
6908               else
6909                 iverdaux->vda_nextptr = NULL;
6910
6911               if (iverdaux->vda_next
6912                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6913                 goto error_return_verdef;
6914
6915               everdaux = ((Elf_External_Verdaux *)
6916                           ((bfd_byte *) everdaux + iverdaux->vda_next));
6917             }
6918
6919           if (iverdef->vd_cnt)
6920             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6921
6922           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
6923             iverdef->vd_nextdef = iverdef + 1;
6924           else
6925             iverdef->vd_nextdef = NULL;
6926
6927           everdef = ((Elf_External_Verdef *)
6928                      ((bfd_byte *) everdef + iverdef->vd_next));
6929         }
6930
6931       free (contents);
6932       contents = NULL;
6933     }
6934   else if (default_imported_symver)
6935     {
6936       if (freeidx < 3)
6937         freeidx = 3;
6938       else
6939         freeidx++;
6940
6941       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6942                                               sizeof (Elf_Internal_Verdef));
6943       if (elf_tdata (abfd)->verdef == NULL)
6944         goto error_return;
6945
6946       elf_tdata (abfd)->cverdefs = freeidx;
6947     }
6948
6949   /* Create a default version based on the soname.  */
6950   if (default_imported_symver)
6951     {
6952       Elf_Internal_Verdef *iverdef;
6953       Elf_Internal_Verdaux *iverdaux;
6954
6955       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6956
6957       iverdef->vd_version = VER_DEF_CURRENT;
6958       iverdef->vd_flags = 0;
6959       iverdef->vd_ndx = freeidx;
6960       iverdef->vd_cnt = 1;
6961
6962       iverdef->vd_bfd = abfd;
6963
6964       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6965       if (iverdef->vd_nodename == NULL)
6966         goto error_return_verdef;
6967       iverdef->vd_nextdef = NULL;
6968       iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6969       if (iverdef->vd_auxptr == NULL)
6970         goto error_return_verdef;
6971
6972       iverdaux = iverdef->vd_auxptr;
6973       iverdaux->vda_nodename = iverdef->vd_nodename;
6974       iverdaux->vda_nextptr = NULL;
6975     }
6976
6977   return TRUE;
6978
6979  error_return:
6980   if (contents != NULL)
6981     free (contents);
6982   return FALSE;
6983 }
6984 \f
6985 asymbol *
6986 _bfd_elf_make_empty_symbol (bfd *abfd)
6987 {
6988   elf_symbol_type *newsym;
6989   bfd_size_type amt = sizeof (elf_symbol_type);
6990
6991   newsym = bfd_zalloc (abfd, amt);
6992   if (!newsym)
6993     return NULL;
6994   else
6995     {
6996       newsym->symbol.the_bfd = abfd;
6997       return &newsym->symbol;
6998     }
6999 }
7000
7001 void
7002 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7003                           asymbol *symbol,
7004                           symbol_info *ret)
7005 {
7006   bfd_symbol_info (symbol, ret);
7007 }
7008
7009 /* Return whether a symbol name implies a local symbol.  Most targets
7010    use this function for the is_local_label_name entry point, but some
7011    override it.  */
7012
7013 bfd_boolean
7014 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7015                               const char *name)
7016 {
7017   /* Normal local symbols start with ``.L''.  */
7018   if (name[0] == '.' && name[1] == 'L')
7019     return TRUE;
7020
7021   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7022      DWARF debugging symbols starting with ``..''.  */
7023   if (name[0] == '.' && name[1] == '.')
7024     return TRUE;
7025
7026   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7027      emitting DWARF debugging output.  I suspect this is actually a
7028      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7029      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7030      underscore to be emitted on some ELF targets).  For ease of use,
7031      we treat such symbols as local.  */
7032   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
7033     return TRUE;
7034
7035   return FALSE;
7036 }
7037
7038 alent *
7039 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7040                      asymbol *symbol ATTRIBUTE_UNUSED)
7041 {
7042   abort ();
7043   return NULL;
7044 }
7045
7046 bfd_boolean
7047 _bfd_elf_set_arch_mach (bfd *abfd,
7048                         enum bfd_architecture arch,
7049                         unsigned long machine)
7050 {
7051   /* If this isn't the right architecture for this backend, and this
7052      isn't the generic backend, fail.  */
7053   if (arch != get_elf_backend_data (abfd)->arch
7054       && arch != bfd_arch_unknown
7055       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
7056     return FALSE;
7057
7058   return bfd_default_set_arch_mach (abfd, arch, machine);
7059 }
7060
7061 /* Find the function to a particular section and offset,
7062    for error reporting.  */
7063
7064 static bfd_boolean
7065 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
7066                    asection *section,
7067                    asymbol **symbols,
7068                    bfd_vma offset,
7069                    const char **filename_ptr,
7070                    const char **functionname_ptr)
7071 {
7072   const char *filename;
7073   asymbol *func, *file;
7074   bfd_vma low_func;
7075   asymbol **p;
7076   /* ??? Given multiple file symbols, it is impossible to reliably
7077      choose the right file name for global symbols.  File symbols are
7078      local symbols, and thus all file symbols must sort before any
7079      global symbols.  The ELF spec may be interpreted to say that a
7080      file symbol must sort before other local symbols, but currently
7081      ld -r doesn't do this.  So, for ld -r output, it is possible to
7082      make a better choice of file name for local symbols by ignoring
7083      file symbols appearing after a given local symbol.  */
7084   enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7085
7086   filename = NULL;
7087   func = NULL;
7088   file = NULL;
7089   low_func = 0;
7090   state = nothing_seen;
7091
7092   for (p = symbols; *p != NULL; p++)
7093     {
7094       elf_symbol_type *q;
7095
7096       q = (elf_symbol_type *) *p;
7097
7098       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7099         {
7100         default:
7101           break;
7102         case STT_FILE:
7103           file = &q->symbol;
7104           if (state == symbol_seen)
7105             state = file_after_symbol_seen;
7106           continue;
7107         case STT_NOTYPE:
7108         case STT_FUNC:
7109           if (bfd_get_section (&q->symbol) == section
7110               && q->symbol.value >= low_func
7111               && q->symbol.value <= offset)
7112             {
7113               func = (asymbol *) q;
7114               low_func = q->symbol.value;
7115               filename = NULL;
7116               if (file != NULL
7117                   && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
7118                       || state != file_after_symbol_seen))
7119                 filename = bfd_asymbol_name (file);
7120             }
7121           break;
7122         }
7123       if (state == nothing_seen)
7124         state = symbol_seen;
7125     }
7126
7127   if (func == NULL)
7128     return FALSE;
7129
7130   if (filename_ptr)
7131     *filename_ptr = filename;
7132   if (functionname_ptr)
7133     *functionname_ptr = bfd_asymbol_name (func);
7134
7135   return TRUE;
7136 }
7137
7138 /* Find the nearest line to a particular section and offset,
7139    for error reporting.  */
7140
7141 bfd_boolean
7142 _bfd_elf_find_nearest_line (bfd *abfd,
7143                             asection *section,
7144                             asymbol **symbols,
7145                             bfd_vma offset,
7146                             const char **filename_ptr,
7147                             const char **functionname_ptr,
7148                             unsigned int *line_ptr)
7149 {
7150   bfd_boolean found;
7151
7152   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7153                                      filename_ptr, functionname_ptr,
7154                                      line_ptr))
7155     {
7156       if (!*functionname_ptr)
7157         elf_find_function (abfd, section, symbols, offset,
7158                            *filename_ptr ? NULL : filename_ptr,
7159                            functionname_ptr);
7160
7161       return TRUE;
7162     }
7163
7164   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7165                                      filename_ptr, functionname_ptr,
7166                                      line_ptr, 0,
7167                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7168     {
7169       if (!*functionname_ptr)
7170         elf_find_function (abfd, section, symbols, offset,
7171                            *filename_ptr ? NULL : filename_ptr,
7172                            functionname_ptr);
7173
7174       return TRUE;
7175     }
7176
7177   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7178                                              &found, filename_ptr,
7179                                              functionname_ptr, line_ptr,
7180                                              &elf_tdata (abfd)->line_info))
7181     return FALSE;
7182   if (found && (*functionname_ptr || *line_ptr))
7183     return TRUE;
7184
7185   if (symbols == NULL)
7186     return FALSE;
7187
7188   if (! elf_find_function (abfd, section, symbols, offset,
7189                            filename_ptr, functionname_ptr))
7190     return FALSE;
7191
7192   *line_ptr = 0;
7193   return TRUE;
7194 }
7195
7196 /* Find the line for a symbol.  */
7197
7198 bfd_boolean
7199 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7200                     const char **filename_ptr, unsigned int *line_ptr)
7201 {
7202   return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7203                                 filename_ptr, line_ptr, 0,
7204                                 &elf_tdata (abfd)->dwarf2_find_line_info);
7205 }
7206
7207 /* After a call to bfd_find_nearest_line, successive calls to
7208    bfd_find_inliner_info can be used to get source information about
7209    each level of function inlining that terminated at the address
7210    passed to bfd_find_nearest_line.  Currently this is only supported
7211    for DWARF2 with appropriate DWARF3 extensions. */
7212
7213 bfd_boolean
7214 _bfd_elf_find_inliner_info (bfd *abfd,
7215                             const char **filename_ptr,
7216                             const char **functionname_ptr,
7217                             unsigned int *line_ptr)
7218 {
7219   bfd_boolean found;
7220   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7221                                          functionname_ptr, line_ptr,
7222                                          & elf_tdata (abfd)->dwarf2_find_line_info);
7223   return found;
7224 }
7225
7226 int
7227 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7228 {
7229   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7230   int ret = bed->s->sizeof_ehdr;
7231
7232   if (!info->relocatable)
7233     {
7234       bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7235
7236       if (phdr_size == (bfd_size_type) -1)
7237         {
7238           struct elf_segment_map *m;
7239
7240           phdr_size = 0;
7241           for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7242             phdr_size += bed->s->sizeof_phdr;
7243
7244           if (phdr_size == 0)
7245             phdr_size = get_program_header_size (abfd, info);
7246         }
7247
7248       elf_tdata (abfd)->program_header_size = phdr_size;
7249       ret += phdr_size;
7250     }
7251
7252   return ret;
7253 }
7254
7255 bfd_boolean
7256 _bfd_elf_set_section_contents (bfd *abfd,
7257                                sec_ptr section,
7258                                const void *location,
7259                                file_ptr offset,
7260                                bfd_size_type count)
7261 {
7262   Elf_Internal_Shdr *hdr;
7263   bfd_signed_vma pos;
7264
7265   if (! abfd->output_has_begun
7266       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7267     return FALSE;
7268
7269   hdr = &elf_section_data (section)->this_hdr;
7270   pos = hdr->sh_offset + offset;
7271   if (bfd_seek (abfd, pos, SEEK_SET) != 0
7272       || bfd_bwrite (location, count, abfd) != count)
7273     return FALSE;
7274
7275   return TRUE;
7276 }
7277
7278 void
7279 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7280                            arelent *cache_ptr ATTRIBUTE_UNUSED,
7281                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7282 {
7283   abort ();
7284 }
7285
7286 /* Try to convert a non-ELF reloc into an ELF one.  */
7287
7288 bfd_boolean
7289 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7290 {
7291   /* Check whether we really have an ELF howto.  */
7292
7293   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7294     {
7295       bfd_reloc_code_real_type code;
7296       reloc_howto_type *howto;
7297
7298       /* Alien reloc: Try to determine its type to replace it with an
7299          equivalent ELF reloc.  */
7300
7301       if (areloc->howto->pc_relative)
7302         {
7303           switch (areloc->howto->bitsize)
7304             {
7305             case 8:
7306               code = BFD_RELOC_8_PCREL;
7307               break;
7308             case 12:
7309               code = BFD_RELOC_12_PCREL;
7310               break;
7311             case 16:
7312               code = BFD_RELOC_16_PCREL;
7313               break;
7314             case 24:
7315               code = BFD_RELOC_24_PCREL;
7316               break;
7317             case 32:
7318               code = BFD_RELOC_32_PCREL;
7319               break;
7320             case 64:
7321               code = BFD_RELOC_64_PCREL;
7322               break;
7323             default:
7324               goto fail;
7325             }
7326
7327           howto = bfd_reloc_type_lookup (abfd, code);
7328
7329           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7330             {
7331               if (howto->pcrel_offset)
7332                 areloc->addend += areloc->address;
7333               else
7334                 areloc->addend -= areloc->address; /* addend is unsigned!! */
7335             }
7336         }
7337       else
7338         {
7339           switch (areloc->howto->bitsize)
7340             {
7341             case 8:
7342               code = BFD_RELOC_8;
7343               break;
7344             case 14:
7345               code = BFD_RELOC_14;
7346               break;
7347             case 16:
7348               code = BFD_RELOC_16;
7349               break;
7350             case 26:
7351               code = BFD_RELOC_26;
7352               break;
7353             case 32:
7354               code = BFD_RELOC_32;
7355               break;
7356             case 64:
7357               code = BFD_RELOC_64;
7358               break;
7359             default:
7360               goto fail;
7361             }
7362
7363           howto = bfd_reloc_type_lookup (abfd, code);
7364         }
7365
7366       if (howto)
7367         areloc->howto = howto;
7368       else
7369         goto fail;
7370     }
7371
7372   return TRUE;
7373
7374  fail:
7375   (*_bfd_error_handler)
7376     (_("%B: unsupported relocation type %s"),
7377      abfd, areloc->howto->name);
7378   bfd_set_error (bfd_error_bad_value);
7379   return FALSE;
7380 }
7381
7382 bfd_boolean
7383 _bfd_elf_close_and_cleanup (bfd *abfd)
7384 {
7385   if (bfd_get_format (abfd) == bfd_object)
7386     {
7387       if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
7388         _bfd_elf_strtab_free (elf_shstrtab (abfd));
7389       _bfd_dwarf2_cleanup_debug_info (abfd);
7390     }
7391
7392   return _bfd_generic_close_and_cleanup (abfd);
7393 }
7394
7395 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7396    in the relocation's offset.  Thus we cannot allow any sort of sanity
7397    range-checking to interfere.  There is nothing else to do in processing
7398    this reloc.  */
7399
7400 bfd_reloc_status_type
7401 _bfd_elf_rel_vtable_reloc_fn
7402   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7403    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7404    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7405    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7406 {
7407   return bfd_reloc_ok;
7408 }
7409 \f
7410 /* Elf core file support.  Much of this only works on native
7411    toolchains, since we rely on knowing the
7412    machine-dependent procfs structure in order to pick
7413    out details about the corefile.  */
7414
7415 #ifdef HAVE_SYS_PROCFS_H
7416 # include <sys/procfs.h>
7417 #endif
7418
7419 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
7420
7421 static int
7422 elfcore_make_pid (bfd *abfd)
7423 {
7424   return ((elf_tdata (abfd)->core_lwpid << 16)
7425           + (elf_tdata (abfd)->core_pid));
7426 }
7427
7428 /* If there isn't a section called NAME, make one, using
7429    data from SECT.  Note, this function will generate a
7430    reference to NAME, so you shouldn't deallocate or
7431    overwrite it.  */
7432
7433 static bfd_boolean
7434 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7435 {
7436   asection *sect2;
7437
7438   if (bfd_get_section_by_name (abfd, name) != NULL)
7439     return TRUE;
7440
7441   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7442   if (sect2 == NULL)
7443     return FALSE;
7444
7445   sect2->size = sect->size;
7446   sect2->filepos = sect->filepos;
7447   sect2->alignment_power = sect->alignment_power;
7448   return TRUE;
7449 }
7450
7451 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
7452    actually creates up to two pseudosections:
7453    - For the single-threaded case, a section named NAME, unless
7454      such a section already exists.
7455    - For the multi-threaded case, a section named "NAME/PID", where
7456      PID is elfcore_make_pid (abfd).
7457    Both pseudosections have identical contents. */
7458 bfd_boolean
7459 _bfd_elfcore_make_pseudosection (bfd *abfd,
7460                                  char *name,
7461                                  size_t size,
7462                                  ufile_ptr filepos)
7463 {
7464   char buf[100];
7465   char *threaded_name;
7466   size_t len;
7467   asection *sect;
7468
7469   /* Build the section name.  */
7470
7471   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7472   len = strlen (buf) + 1;
7473   threaded_name = bfd_alloc (abfd, len);
7474   if (threaded_name == NULL)
7475     return FALSE;
7476   memcpy (threaded_name, buf, len);
7477
7478   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7479                                              SEC_HAS_CONTENTS);
7480   if (sect == NULL)
7481     return FALSE;
7482   sect->size = size;
7483   sect->filepos = filepos;
7484   sect->alignment_power = 2;
7485
7486   return elfcore_maybe_make_sect (abfd, name, sect);
7487 }
7488
7489 /* prstatus_t exists on:
7490      solaris 2.5+
7491      linux 2.[01] + glibc
7492      unixware 4.2
7493 */
7494
7495 #if defined (HAVE_PRSTATUS_T)
7496
7497 static bfd_boolean
7498 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7499 {
7500   size_t size;
7501   int offset;
7502
7503   if (note->descsz == sizeof (prstatus_t))
7504     {
7505       prstatus_t prstat;
7506
7507       size = sizeof (prstat.pr_reg);
7508       offset   = offsetof (prstatus_t, pr_reg);
7509       memcpy (&prstat, note->descdata, sizeof (prstat));
7510
7511       /* Do not overwrite the core signal if it
7512          has already been set by another thread.  */
7513       if (elf_tdata (abfd)->core_signal == 0)
7514         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7515       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7516
7517       /* pr_who exists on:
7518          solaris 2.5+
7519          unixware 4.2
7520          pr_who doesn't exist on:
7521          linux 2.[01]
7522          */
7523 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7524       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7525 #endif
7526     }
7527 #if defined (HAVE_PRSTATUS32_T)
7528   else if (note->descsz == sizeof (prstatus32_t))
7529     {
7530       /* 64-bit host, 32-bit corefile */
7531       prstatus32_t prstat;
7532
7533       size = sizeof (prstat.pr_reg);
7534       offset   = offsetof (prstatus32_t, pr_reg);
7535       memcpy (&prstat, note->descdata, sizeof (prstat));
7536
7537       /* Do not overwrite the core signal if it
7538          has already been set by another thread.  */
7539       if (elf_tdata (abfd)->core_signal == 0)
7540         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7541       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7542
7543       /* pr_who exists on:
7544          solaris 2.5+
7545          unixware 4.2
7546          pr_who doesn't exist on:
7547          linux 2.[01]
7548          */
7549 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7550       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7551 #endif
7552     }
7553 #endif /* HAVE_PRSTATUS32_T */
7554   else
7555     {
7556       /* Fail - we don't know how to handle any other
7557          note size (ie. data object type).  */
7558       return TRUE;
7559     }
7560
7561   /* Make a ".reg/999" section and a ".reg" section.  */
7562   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7563                                           size, note->descpos + offset);
7564 }
7565 #endif /* defined (HAVE_PRSTATUS_T) */
7566
7567 /* Create a pseudosection containing the exact contents of NOTE.  */
7568 static bfd_boolean
7569 elfcore_make_note_pseudosection (bfd *abfd,
7570                                  char *name,
7571                                  Elf_Internal_Note *note)
7572 {
7573   return _bfd_elfcore_make_pseudosection (abfd, name,
7574                                           note->descsz, note->descpos);
7575 }
7576
7577 /* There isn't a consistent prfpregset_t across platforms,
7578    but it doesn't matter, because we don't have to pick this
7579    data structure apart.  */
7580
7581 static bfd_boolean
7582 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7583 {
7584   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7585 }
7586
7587 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7588    type of NT_PRXFPREG.  Just include the whole note's contents
7589    literally.  */
7590
7591 static bfd_boolean
7592 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7593 {
7594   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7595 }
7596
7597 static bfd_boolean
7598 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
7599 {
7600   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
7601 }
7602
7603 static bfd_boolean
7604 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
7605 {
7606   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
7607 }
7608
7609 #if defined (HAVE_PRPSINFO_T)
7610 typedef prpsinfo_t   elfcore_psinfo_t;
7611 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
7612 typedef prpsinfo32_t elfcore_psinfo32_t;
7613 #endif
7614 #endif
7615
7616 #if defined (HAVE_PSINFO_T)
7617 typedef psinfo_t   elfcore_psinfo_t;
7618 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
7619 typedef psinfo32_t elfcore_psinfo32_t;
7620 #endif
7621 #endif
7622
7623 /* return a malloc'ed copy of a string at START which is at
7624    most MAX bytes long, possibly without a terminating '\0'.
7625    the copy will always have a terminating '\0'.  */
7626
7627 char *
7628 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7629 {
7630   char *dups;
7631   char *end = memchr (start, '\0', max);
7632   size_t len;
7633
7634   if (end == NULL)
7635     len = max;
7636   else
7637     len = end - start;
7638
7639   dups = bfd_alloc (abfd, len + 1);
7640   if (dups == NULL)
7641     return NULL;
7642
7643   memcpy (dups, start, len);
7644   dups[len] = '\0';
7645
7646   return dups;
7647 }
7648
7649 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7650 static bfd_boolean
7651 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7652 {
7653   if (note->descsz == sizeof (elfcore_psinfo_t))
7654     {
7655       elfcore_psinfo_t psinfo;
7656
7657       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7658
7659       elf_tdata (abfd)->core_program
7660         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7661                                 sizeof (psinfo.pr_fname));
7662
7663       elf_tdata (abfd)->core_command
7664         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7665                                 sizeof (psinfo.pr_psargs));
7666     }
7667 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7668   else if (note->descsz == sizeof (elfcore_psinfo32_t))
7669     {
7670       /* 64-bit host, 32-bit corefile */
7671       elfcore_psinfo32_t psinfo;
7672
7673       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7674
7675       elf_tdata (abfd)->core_program
7676         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7677                                 sizeof (psinfo.pr_fname));
7678
7679       elf_tdata (abfd)->core_command
7680         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7681                                 sizeof (psinfo.pr_psargs));
7682     }
7683 #endif
7684
7685   else
7686     {
7687       /* Fail - we don't know how to handle any other
7688          note size (ie. data object type).  */
7689       return TRUE;
7690     }
7691
7692   /* Note that for some reason, a spurious space is tacked
7693      onto the end of the args in some (at least one anyway)
7694      implementations, so strip it off if it exists.  */
7695
7696   {
7697     char *command = elf_tdata (abfd)->core_command;
7698     int n = strlen (command);
7699
7700     if (0 < n && command[n - 1] == ' ')
7701       command[n - 1] = '\0';
7702   }
7703
7704   return TRUE;
7705 }
7706 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7707
7708 #if defined (HAVE_PSTATUS_T)
7709 static bfd_boolean
7710 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7711 {
7712   if (note->descsz == sizeof (pstatus_t)
7713 #if defined (HAVE_PXSTATUS_T)
7714       || note->descsz == sizeof (pxstatus_t)
7715 #endif
7716       )
7717     {
7718       pstatus_t pstat;
7719
7720       memcpy (&pstat, note->descdata, sizeof (pstat));
7721
7722       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7723     }
7724 #if defined (HAVE_PSTATUS32_T)
7725   else if (note->descsz == sizeof (pstatus32_t))
7726     {
7727       /* 64-bit host, 32-bit corefile */
7728       pstatus32_t pstat;
7729
7730       memcpy (&pstat, note->descdata, sizeof (pstat));
7731
7732       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7733     }
7734 #endif
7735   /* Could grab some more details from the "representative"
7736      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7737      NT_LWPSTATUS note, presumably.  */
7738
7739   return TRUE;
7740 }
7741 #endif /* defined (HAVE_PSTATUS_T) */
7742
7743 #if defined (HAVE_LWPSTATUS_T)
7744 static bfd_boolean
7745 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7746 {
7747   lwpstatus_t lwpstat;
7748   char buf[100];
7749   char *name;
7750   size_t len;
7751   asection *sect;
7752
7753   if (note->descsz != sizeof (lwpstat)
7754 #if defined (HAVE_LWPXSTATUS_T)
7755       && note->descsz != sizeof (lwpxstatus_t)
7756 #endif
7757       )
7758     return TRUE;
7759
7760   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7761
7762   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7763   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7764
7765   /* Make a ".reg/999" section.  */
7766
7767   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7768   len = strlen (buf) + 1;
7769   name = bfd_alloc (abfd, len);
7770   if (name == NULL)
7771     return FALSE;
7772   memcpy (name, buf, len);
7773
7774   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7775   if (sect == NULL)
7776     return FALSE;
7777
7778 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7779   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7780   sect->filepos = note->descpos
7781     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7782 #endif
7783
7784 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7785   sect->size = sizeof (lwpstat.pr_reg);
7786   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7787 #endif
7788
7789   sect->alignment_power = 2;
7790
7791   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7792     return FALSE;
7793
7794   /* Make a ".reg2/999" section */
7795
7796   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7797   len = strlen (buf) + 1;
7798   name = bfd_alloc (abfd, len);
7799   if (name == NULL)
7800     return FALSE;
7801   memcpy (name, buf, len);
7802
7803   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7804   if (sect == NULL)
7805     return FALSE;
7806
7807 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7808   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7809   sect->filepos = note->descpos
7810     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7811 #endif
7812
7813 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7814   sect->size = sizeof (lwpstat.pr_fpreg);
7815   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7816 #endif
7817
7818   sect->alignment_power = 2;
7819
7820   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7821 }
7822 #endif /* defined (HAVE_LWPSTATUS_T) */
7823
7824 static bfd_boolean
7825 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7826 {
7827   char buf[30];
7828   char *name;
7829   size_t len;
7830   asection *sect;
7831   int type;
7832   int is_active_thread;
7833   bfd_vma base_addr;
7834
7835   if (note->descsz < 728)
7836     return TRUE;
7837
7838   if (! CONST_STRNEQ (note->namedata, "win32"))
7839     return TRUE;
7840
7841   type = bfd_get_32 (abfd, note->descdata);
7842
7843   switch (type)
7844     {
7845     case 1 /* NOTE_INFO_PROCESS */:
7846       /* FIXME: need to add ->core_command.  */
7847       /* process_info.pid */
7848       elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
7849       /* process_info.signal */
7850       elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
7851       break;
7852
7853     case 2 /* NOTE_INFO_THREAD */:
7854       /* Make a ".reg/999" section.  */
7855       /* thread_info.tid */
7856       sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
7857
7858       len = strlen (buf) + 1;
7859       name = bfd_alloc (abfd, len);
7860       if (name == NULL)
7861         return FALSE;
7862
7863       memcpy (name, buf, len);
7864
7865       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7866       if (sect == NULL)
7867         return FALSE;
7868
7869       /* sizeof (thread_info.thread_context) */
7870       sect->size = 716;
7871       /* offsetof (thread_info.thread_context) */
7872       sect->filepos = note->descpos + 12;
7873       sect->alignment_power = 2;
7874
7875       /* thread_info.is_active_thread */
7876       is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
7877
7878       if (is_active_thread)
7879         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7880           return FALSE;
7881       break;
7882
7883     case 3 /* NOTE_INFO_MODULE */:
7884       /* Make a ".module/xxxxxxxx" section.  */
7885       /* module_info.base_address */
7886       base_addr = bfd_get_32 (abfd, note->descdata + 4);
7887       sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
7888
7889       len = strlen (buf) + 1;
7890       name = bfd_alloc (abfd, len);
7891       if (name == NULL)
7892         return FALSE;
7893
7894       memcpy (name, buf, len);
7895
7896       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7897
7898       if (sect == NULL)
7899         return FALSE;
7900
7901       sect->size = note->descsz;
7902       sect->filepos = note->descpos;
7903       sect->alignment_power = 2;
7904       break;
7905
7906     default:
7907       return TRUE;
7908     }
7909
7910   return TRUE;
7911 }
7912
7913 static bfd_boolean
7914 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7915 {
7916   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7917
7918   switch (note->type)
7919     {
7920     default:
7921       return TRUE;
7922
7923     case NT_PRSTATUS:
7924       if (bed->elf_backend_grok_prstatus)
7925         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7926           return TRUE;
7927 #if defined (HAVE_PRSTATUS_T)
7928       return elfcore_grok_prstatus (abfd, note);
7929 #else
7930       return TRUE;
7931 #endif
7932
7933 #if defined (HAVE_PSTATUS_T)
7934     case NT_PSTATUS:
7935       return elfcore_grok_pstatus (abfd, note);
7936 #endif
7937
7938 #if defined (HAVE_LWPSTATUS_T)
7939     case NT_LWPSTATUS:
7940       return elfcore_grok_lwpstatus (abfd, note);
7941 #endif
7942
7943     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
7944       return elfcore_grok_prfpreg (abfd, note);
7945
7946     case NT_WIN32PSTATUS:
7947       return elfcore_grok_win32pstatus (abfd, note);
7948
7949     case NT_PRXFPREG:           /* Linux SSE extension */
7950       if (note->namesz == 6
7951           && strcmp (note->namedata, "LINUX") == 0)
7952         return elfcore_grok_prxfpreg (abfd, note);
7953       else
7954         return TRUE;
7955
7956     case NT_PPC_VMX:
7957       if (note->namesz == 6
7958           && strcmp (note->namedata, "LINUX") == 0)
7959         return elfcore_grok_ppc_vmx (abfd, note);
7960       else
7961         return TRUE;
7962
7963     case NT_PPC_VSX:
7964       if (note->namesz == 6
7965           && strcmp (note->namedata, "LINUX") == 0)
7966         return elfcore_grok_ppc_vsx (abfd, note);
7967       else
7968         return TRUE;
7969
7970     case NT_PRPSINFO:
7971     case NT_PSINFO:
7972       if (bed->elf_backend_grok_psinfo)
7973         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7974           return TRUE;
7975 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7976       return elfcore_grok_psinfo (abfd, note);
7977 #else
7978       return TRUE;
7979 #endif
7980
7981     case NT_AUXV:
7982       {
7983         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
7984                                                              SEC_HAS_CONTENTS);
7985
7986         if (sect == NULL)
7987           return FALSE;
7988         sect->size = note->descsz;
7989         sect->filepos = note->descpos;
7990         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7991
7992         return TRUE;
7993       }
7994     }
7995 }
7996
7997 static bfd_boolean
7998 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
7999 {
8000   elf_tdata (abfd)->build_id_size = note->descsz;
8001   elf_tdata (abfd)->build_id = bfd_alloc (abfd, note->descsz);
8002   if (elf_tdata (abfd)->build_id == NULL)
8003     return FALSE;
8004
8005   memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
8006
8007   return TRUE;
8008 }
8009
8010 static bfd_boolean
8011 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8012 {
8013   switch (note->type)
8014     {
8015     default:
8016       return TRUE;
8017
8018     case NT_GNU_BUILD_ID:
8019       return elfobj_grok_gnu_build_id (abfd, note);
8020     }
8021 }
8022
8023 static bfd_boolean
8024 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
8025 {
8026   char *cp;
8027
8028   cp = strchr (note->namedata, '@');
8029   if (cp != NULL)
8030     {
8031       *lwpidp = atoi(cp + 1);
8032       return TRUE;
8033     }
8034   return FALSE;
8035 }
8036
8037 static bfd_boolean
8038 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8039 {
8040   /* Signal number at offset 0x08. */
8041   elf_tdata (abfd)->core_signal
8042     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8043
8044   /* Process ID at offset 0x50. */
8045   elf_tdata (abfd)->core_pid
8046     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8047
8048   /* Command name at 0x7c (max 32 bytes, including nul). */
8049   elf_tdata (abfd)->core_command
8050     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8051
8052   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8053                                           note);
8054 }
8055
8056 static bfd_boolean
8057 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
8058 {
8059   int lwp;
8060
8061   if (elfcore_netbsd_get_lwpid (note, &lwp))
8062     elf_tdata (abfd)->core_lwpid = lwp;
8063
8064   if (note->type == NT_NETBSDCORE_PROCINFO)
8065     {
8066       /* NetBSD-specific core "procinfo".  Note that we expect to
8067          find this note before any of the others, which is fine,
8068          since the kernel writes this note out first when it
8069          creates a core file.  */
8070
8071       return elfcore_grok_netbsd_procinfo (abfd, note);
8072     }
8073
8074   /* As of Jan 2002 there are no other machine-independent notes
8075      defined for NetBSD core files.  If the note type is less
8076      than the start of the machine-dependent note types, we don't
8077      understand it.  */
8078
8079   if (note->type < NT_NETBSDCORE_FIRSTMACH)
8080     return TRUE;
8081
8082
8083   switch (bfd_get_arch (abfd))
8084     {
8085       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8086          PT_GETFPREGS == mach+2.  */
8087
8088     case bfd_arch_alpha:
8089     case bfd_arch_sparc:
8090       switch (note->type)
8091         {
8092         case NT_NETBSDCORE_FIRSTMACH+0:
8093           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8094
8095         case NT_NETBSDCORE_FIRSTMACH+2:
8096           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8097
8098         default:
8099           return TRUE;
8100         }
8101
8102       /* On all other arch's, PT_GETREGS == mach+1 and
8103          PT_GETFPREGS == mach+3.  */
8104
8105     default:
8106       switch (note->type)
8107         {
8108         case NT_NETBSDCORE_FIRSTMACH+1:
8109           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8110
8111         case NT_NETBSDCORE_FIRSTMACH+3:
8112           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8113
8114         default:
8115           return TRUE;
8116         }
8117     }
8118     /* NOTREACHED */
8119 }
8120
8121 static bfd_boolean
8122 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8123 {
8124   void *ddata = note->descdata;
8125   char buf[100];
8126   char *name;
8127   asection *sect;
8128   short sig;
8129   unsigned flags;
8130
8131   /* nto_procfs_status 'pid' field is at offset 0.  */
8132   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8133
8134   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
8135   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8136
8137   /* nto_procfs_status 'flags' field is at offset 8.  */
8138   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8139
8140   /* nto_procfs_status 'what' field is at offset 14.  */
8141   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8142     {
8143       elf_tdata (abfd)->core_signal = sig;
8144       elf_tdata (abfd)->core_lwpid = *tid;
8145     }
8146
8147   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
8148      do not come from signals so we make sure we set the current
8149      thread just in case.  */
8150   if (flags & 0x00000080)
8151     elf_tdata (abfd)->core_lwpid = *tid;
8152
8153   /* Make a ".qnx_core_status/%d" section.  */
8154   sprintf (buf, ".qnx_core_status/%ld", *tid);
8155
8156   name = bfd_alloc (abfd, strlen (buf) + 1);
8157   if (name == NULL)
8158     return FALSE;
8159   strcpy (name, buf);
8160
8161   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8162   if (sect == NULL)
8163     return FALSE;
8164
8165   sect->size            = note->descsz;
8166   sect->filepos         = note->descpos;
8167   sect->alignment_power = 2;
8168
8169   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8170 }
8171
8172 static bfd_boolean
8173 elfcore_grok_nto_regs (bfd *abfd,
8174                        Elf_Internal_Note *note,
8175                        long tid,
8176                        char *base)
8177 {
8178   char buf[100];
8179   char *name;
8180   asection *sect;
8181
8182   /* Make a "(base)/%d" section.  */
8183   sprintf (buf, "%s/%ld", base, tid);
8184
8185   name = bfd_alloc (abfd, strlen (buf) + 1);
8186   if (name == NULL)
8187     return FALSE;
8188   strcpy (name, buf);
8189
8190   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8191   if (sect == NULL)
8192     return FALSE;
8193
8194   sect->size            = note->descsz;
8195   sect->filepos         = note->descpos;
8196   sect->alignment_power = 2;
8197
8198   /* This is the current thread.  */
8199   if (elf_tdata (abfd)->core_lwpid == tid)
8200     return elfcore_maybe_make_sect (abfd, base, sect);
8201
8202   return TRUE;
8203 }
8204
8205 #define BFD_QNT_CORE_INFO       7
8206 #define BFD_QNT_CORE_STATUS     8
8207 #define BFD_QNT_CORE_GREG       9
8208 #define BFD_QNT_CORE_FPREG      10
8209
8210 static bfd_boolean
8211 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8212 {
8213   /* Every GREG section has a STATUS section before it.  Store the
8214      tid from the previous call to pass down to the next gregs
8215      function.  */
8216   static long tid = 1;
8217
8218   switch (note->type)
8219     {
8220     case BFD_QNT_CORE_INFO:
8221       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8222     case BFD_QNT_CORE_STATUS:
8223       return elfcore_grok_nto_status (abfd, note, &tid);
8224     case BFD_QNT_CORE_GREG:
8225       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8226     case BFD_QNT_CORE_FPREG:
8227       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8228     default:
8229       return TRUE;
8230     }
8231 }
8232
8233 static bfd_boolean
8234 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8235 {
8236   char *name;
8237   asection *sect;
8238   size_t len;
8239
8240   /* Use note name as section name.  */
8241   len = note->namesz;
8242   name = bfd_alloc (abfd, len);
8243   if (name == NULL)
8244     return FALSE;
8245   memcpy (name, note->namedata, len);
8246   name[len - 1] = '\0';
8247
8248   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8249   if (sect == NULL)
8250     return FALSE;
8251
8252   sect->size            = note->descsz;
8253   sect->filepos         = note->descpos;
8254   sect->alignment_power = 1;
8255
8256   return TRUE;
8257 }
8258
8259 /* Function: elfcore_write_note
8260
8261    Inputs:
8262      buffer to hold note, and current size of buffer
8263      name of note
8264      type of note
8265      data for note
8266      size of data for note
8267
8268    Writes note to end of buffer.  ELF64 notes are written exactly as
8269    for ELF32, despite the current (as of 2006) ELF gabi specifying
8270    that they ought to have 8-byte namesz and descsz field, and have
8271    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
8272
8273    Return:
8274    Pointer to realloc'd buffer, *BUFSIZ updated.  */
8275
8276 char *
8277 elfcore_write_note (bfd *abfd,
8278                     char *buf,
8279                     int *bufsiz,
8280                     const char *name,
8281                     int type,
8282                     const void *input,
8283                     int size)
8284 {
8285   Elf_External_Note *xnp;
8286   size_t namesz;
8287   size_t newspace;
8288   char *dest;
8289
8290   namesz = 0;
8291   if (name != NULL)
8292     namesz = strlen (name) + 1;
8293
8294   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
8295
8296   buf = realloc (buf, *bufsiz + newspace);
8297   if (buf == NULL)
8298     return buf;
8299   dest = buf + *bufsiz;
8300   *bufsiz += newspace;
8301   xnp = (Elf_External_Note *) dest;
8302   H_PUT_32 (abfd, namesz, xnp->namesz);
8303   H_PUT_32 (abfd, size, xnp->descsz);
8304   H_PUT_32 (abfd, type, xnp->type);
8305   dest = xnp->name;
8306   if (name != NULL)
8307     {
8308       memcpy (dest, name, namesz);
8309       dest += namesz;
8310       while (namesz & 3)
8311         {
8312           *dest++ = '\0';
8313           ++namesz;
8314         }
8315     }
8316   memcpy (dest, input, size);
8317   dest += size;
8318   while (size & 3)
8319     {
8320       *dest++ = '\0';
8321       ++size;
8322     }
8323   return buf;
8324 }
8325
8326 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8327 char *
8328 elfcore_write_prpsinfo (bfd  *abfd,
8329                         char *buf,
8330                         int  *bufsiz,
8331                         const char *fname,
8332                         const char *psargs)
8333 {
8334   const char *note_name = "CORE";
8335   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8336
8337   if (bed->elf_backend_write_core_note != NULL)
8338     {
8339       char *ret;
8340       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8341                                                  NT_PRPSINFO, fname, psargs);
8342       if (ret != NULL)
8343         return ret;
8344     }
8345
8346 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8347   if (bed->s->elfclass == ELFCLASS32)
8348     {
8349 #if defined (HAVE_PSINFO32_T)
8350       psinfo32_t data;
8351       int note_type = NT_PSINFO;
8352 #else
8353       prpsinfo32_t data;
8354       int note_type = NT_PRPSINFO;
8355 #endif
8356
8357       memset (&data, 0, sizeof (data));
8358       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8359       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8360       return elfcore_write_note (abfd, buf, bufsiz,
8361                                  note_name, note_type, &data, sizeof (data));
8362     }
8363   else
8364 #endif
8365     {
8366 #if defined (HAVE_PSINFO_T)
8367       psinfo_t data;
8368       int note_type = NT_PSINFO;
8369 #else
8370       prpsinfo_t data;
8371       int note_type = NT_PRPSINFO;
8372 #endif
8373
8374       memset (&data, 0, sizeof (data));
8375       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8376       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8377       return elfcore_write_note (abfd, buf, bufsiz,
8378                                  note_name, note_type, &data, sizeof (data));
8379     }
8380 }
8381 #endif  /* PSINFO_T or PRPSINFO_T */
8382
8383 #if defined (HAVE_PRSTATUS_T)
8384 char *
8385 elfcore_write_prstatus (bfd *abfd,
8386                         char *buf,
8387                         int *bufsiz,
8388                         long pid,
8389                         int cursig,
8390                         const void *gregs)
8391 {
8392   const char *note_name = "CORE";
8393   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8394
8395   if (bed->elf_backend_write_core_note != NULL)
8396     {
8397       char *ret;
8398       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8399                                                  NT_PRSTATUS,
8400                                                  pid, cursig, gregs);
8401       if (ret != NULL)
8402         return ret;
8403     }
8404
8405 #if defined (HAVE_PRSTATUS32_T)
8406   if (bed->s->elfclass == ELFCLASS32)
8407     {
8408       prstatus32_t prstat;
8409
8410       memset (&prstat, 0, sizeof (prstat));
8411       prstat.pr_pid = pid;
8412       prstat.pr_cursig = cursig;
8413       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8414       return elfcore_write_note (abfd, buf, bufsiz, note_name,
8415                                  NT_PRSTATUS, &prstat, sizeof (prstat));
8416     }
8417   else
8418 #endif
8419     {
8420       prstatus_t prstat;
8421
8422       memset (&prstat, 0, sizeof (prstat));
8423       prstat.pr_pid = pid;
8424       prstat.pr_cursig = cursig;
8425       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8426       return elfcore_write_note (abfd, buf, bufsiz, note_name,
8427                                  NT_PRSTATUS, &prstat, sizeof (prstat));
8428     }
8429 }
8430 #endif /* HAVE_PRSTATUS_T */
8431
8432 #if defined (HAVE_LWPSTATUS_T)
8433 char *
8434 elfcore_write_lwpstatus (bfd *abfd,
8435                          char *buf,
8436                          int *bufsiz,
8437                          long pid,
8438                          int cursig,
8439                          const void *gregs)
8440 {
8441   lwpstatus_t lwpstat;
8442   const char *note_name = "CORE";
8443
8444   memset (&lwpstat, 0, sizeof (lwpstat));
8445   lwpstat.pr_lwpid  = pid >> 16;
8446   lwpstat.pr_cursig = cursig;
8447 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8448   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8449 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8450 #if !defined(gregs)
8451   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8452           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8453 #else
8454   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8455           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8456 #endif
8457 #endif
8458   return elfcore_write_note (abfd, buf, bufsiz, note_name,
8459                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8460 }
8461 #endif /* HAVE_LWPSTATUS_T */
8462
8463 #if defined (HAVE_PSTATUS_T)
8464 char *
8465 elfcore_write_pstatus (bfd *abfd,
8466                        char *buf,
8467                        int *bufsiz,
8468                        long pid,
8469                        int cursig ATTRIBUTE_UNUSED,
8470                        const void *gregs ATTRIBUTE_UNUSED)
8471 {
8472   const char *note_name = "CORE";
8473 #if defined (HAVE_PSTATUS32_T)
8474   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8475
8476   if (bed->s->elfclass == ELFCLASS32)
8477     {
8478       pstatus32_t pstat;
8479
8480       memset (&pstat, 0, sizeof (pstat));
8481       pstat.pr_pid = pid & 0xffff;
8482       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8483                                 NT_PSTATUS, &pstat, sizeof (pstat));
8484       return buf;
8485     }
8486   else
8487 #endif
8488     {
8489       pstatus_t pstat;
8490
8491       memset (&pstat, 0, sizeof (pstat));
8492       pstat.pr_pid = pid & 0xffff;
8493       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8494                                 NT_PSTATUS, &pstat, sizeof (pstat));
8495       return buf;
8496     }
8497 }
8498 #endif /* HAVE_PSTATUS_T */
8499
8500 char *
8501 elfcore_write_prfpreg (bfd *abfd,
8502                        char *buf,
8503                        int *bufsiz,
8504                        const void *fpregs,
8505                        int size)
8506 {
8507   const char *note_name = "CORE";
8508   return elfcore_write_note (abfd, buf, bufsiz,
8509                              note_name, NT_FPREGSET, fpregs, size);
8510 }
8511
8512 char *
8513 elfcore_write_prxfpreg (bfd *abfd,
8514                         char *buf,
8515                         int *bufsiz,
8516                         const void *xfpregs,
8517                         int size)
8518 {
8519   char *note_name = "LINUX";
8520   return elfcore_write_note (abfd, buf, bufsiz,
8521                              note_name, NT_PRXFPREG, xfpregs, size);
8522 }
8523
8524 char *
8525 elfcore_write_ppc_vmx (bfd *abfd,
8526                        char *buf,
8527                        int *bufsiz,
8528                        const void *ppc_vmx,
8529                        int size)
8530 {
8531   char *note_name = "LINUX";
8532   return elfcore_write_note (abfd, buf, bufsiz,
8533                              note_name, NT_PPC_VMX, ppc_vmx, size);
8534 }
8535
8536 char *
8537 elfcore_write_ppc_vsx (bfd *abfd,
8538                        char *buf,
8539                        int *bufsiz,
8540                        const void *ppc_vsx,
8541                        int size)
8542 {
8543   char *note_name = "LINUX";
8544   return elfcore_write_note (abfd, buf, bufsiz,
8545                              note_name, NT_PPC_VSX, ppc_vsx, size);
8546 }
8547
8548 char *
8549 elfcore_write_register_note (bfd *abfd,
8550                              char *buf,
8551                              int *bufsiz,
8552                              const char *section,
8553                              const void *data,
8554                              int size)
8555 {
8556   if (strcmp (section, ".reg2") == 0)
8557     return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
8558   if (strcmp (section, ".reg-xfp") == 0)
8559     return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
8560   if (strcmp (section, ".reg-ppc-vmx") == 0)
8561     return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
8562   if (strcmp (section, ".reg-ppc-vsx") == 0)
8563     return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
8564   return NULL;
8565 }
8566
8567 static bfd_boolean
8568 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
8569 {
8570   char *p;
8571
8572   p = buf;
8573   while (p < buf + size)
8574     {
8575       /* FIXME: bad alignment assumption.  */
8576       Elf_External_Note *xnp = (Elf_External_Note *) p;
8577       Elf_Internal_Note in;
8578
8579       if (offsetof (Elf_External_Note, name) > buf - p + size)
8580         return FALSE;
8581
8582       in.type = H_GET_32 (abfd, xnp->type);
8583
8584       in.namesz = H_GET_32 (abfd, xnp->namesz);
8585       in.namedata = xnp->name;
8586       if (in.namesz > buf - in.namedata + size)
8587         return FALSE;
8588
8589       in.descsz = H_GET_32 (abfd, xnp->descsz);
8590       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8591       in.descpos = offset + (in.descdata - buf);
8592       if (in.descsz != 0
8593           && (in.descdata >= buf + size
8594               || in.descsz > buf - in.descdata + size))
8595         return FALSE;
8596
8597       switch (bfd_get_format (abfd))
8598         {
8599         default:
8600           return TRUE;
8601
8602         case bfd_core:
8603           if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
8604             {
8605               if (! elfcore_grok_netbsd_note (abfd, &in))
8606                 return FALSE;
8607             }
8608           else if (CONST_STRNEQ (in.namedata, "QNX"))
8609             {
8610               if (! elfcore_grok_nto_note (abfd, &in))
8611                 return FALSE;
8612             }
8613           else if (CONST_STRNEQ (in.namedata, "SPU/"))
8614             {
8615               if (! elfcore_grok_spu_note (abfd, &in))
8616                 return FALSE;
8617             }
8618           else
8619             {
8620               if (! elfcore_grok_note (abfd, &in))
8621                 return FALSE;
8622             }
8623           break;
8624
8625         case bfd_object:
8626           if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
8627             {
8628               if (! elfobj_grok_gnu_note (abfd, &in))
8629                 return FALSE;
8630             }
8631           break;
8632         }
8633
8634       p = in.descdata + BFD_ALIGN (in.descsz, 4);
8635     }
8636
8637   return TRUE;
8638 }
8639
8640 static bfd_boolean
8641 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
8642 {
8643   char *buf;
8644
8645   if (size <= 0)
8646     return TRUE;
8647
8648   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
8649     return FALSE;
8650
8651   buf = bfd_malloc (size);
8652   if (buf == NULL)
8653     return FALSE;
8654
8655   if (bfd_bread (buf, size, abfd) != size
8656       || !elf_parse_notes (abfd, buf, size, offset))
8657     {
8658       free (buf);
8659       return FALSE;
8660     }
8661
8662   free (buf);
8663   return TRUE;
8664 }
8665 \f
8666 /* Providing external access to the ELF program header table.  */
8667
8668 /* Return an upper bound on the number of bytes required to store a
8669    copy of ABFD's program header table entries.  Return -1 if an error
8670    occurs; bfd_get_error will return an appropriate code.  */
8671
8672 long
8673 bfd_get_elf_phdr_upper_bound (bfd *abfd)
8674 {
8675   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8676     {
8677       bfd_set_error (bfd_error_wrong_format);
8678       return -1;
8679     }
8680
8681   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
8682 }
8683
8684 /* Copy ABFD's program header table entries to *PHDRS.  The entries
8685    will be stored as an array of Elf_Internal_Phdr structures, as
8686    defined in include/elf/internal.h.  To find out how large the
8687    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8688
8689    Return the number of program header table entries read, or -1 if an
8690    error occurs; bfd_get_error will return an appropriate code.  */
8691
8692 int
8693 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
8694 {
8695   int num_phdrs;
8696
8697   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8698     {
8699       bfd_set_error (bfd_error_wrong_format);
8700       return -1;
8701     }
8702
8703   num_phdrs = elf_elfheader (abfd)->e_phnum;
8704   memcpy (phdrs, elf_tdata (abfd)->phdr,
8705           num_phdrs * sizeof (Elf_Internal_Phdr));
8706
8707   return num_phdrs;
8708 }
8709
8710 enum elf_reloc_type_class
8711 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8712 {
8713   return reloc_class_normal;
8714 }
8715
8716 /* For RELA architectures, return the relocation value for a
8717    relocation against a local symbol.  */
8718
8719 bfd_vma
8720 _bfd_elf_rela_local_sym (bfd *abfd,
8721                          Elf_Internal_Sym *sym,
8722                          asection **psec,
8723                          Elf_Internal_Rela *rel)
8724 {
8725   asection *sec = *psec;
8726   bfd_vma relocation;
8727
8728   relocation = (sec->output_section->vma
8729                 + sec->output_offset
8730                 + sym->st_value);
8731   if ((sec->flags & SEC_MERGE)
8732       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8733       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8734     {
8735       rel->r_addend =
8736         _bfd_merged_section_offset (abfd, psec,
8737                                     elf_section_data (sec)->sec_info,
8738                                     sym->st_value + rel->r_addend);
8739       if (sec != *psec)
8740         {
8741           /* If we have changed the section, and our original section is
8742              marked with SEC_EXCLUDE, it means that the original
8743              SEC_MERGE section has been completely subsumed in some
8744              other SEC_MERGE section.  In this case, we need to leave
8745              some info around for --emit-relocs.  */
8746           if ((sec->flags & SEC_EXCLUDE) != 0)
8747             sec->kept_section = *psec;
8748           sec = *psec;
8749         }
8750       rel->r_addend -= relocation;
8751       rel->r_addend += sec->output_section->vma + sec->output_offset;
8752     }
8753   return relocation;
8754 }
8755
8756 bfd_vma
8757 _bfd_elf_rel_local_sym (bfd *abfd,
8758                         Elf_Internal_Sym *sym,
8759                         asection **psec,
8760                         bfd_vma addend)
8761 {
8762   asection *sec = *psec;
8763
8764   if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8765     return sym->st_value + addend;
8766
8767   return _bfd_merged_section_offset (abfd, psec,
8768                                      elf_section_data (sec)->sec_info,
8769                                      sym->st_value + addend);
8770 }
8771
8772 bfd_vma
8773 _bfd_elf_section_offset (bfd *abfd,
8774                          struct bfd_link_info *info,
8775                          asection *sec,
8776                          bfd_vma offset)
8777 {
8778   switch (sec->sec_info_type)
8779     {
8780     case ELF_INFO_TYPE_STABS:
8781       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8782                                        offset);
8783     case ELF_INFO_TYPE_EH_FRAME:
8784       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8785     default:
8786       return offset;
8787     }
8788 }
8789 \f
8790 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
8791    reconstruct an ELF file by reading the segments out of remote memory
8792    based on the ELF file header at EHDR_VMA and the ELF program headers it
8793    points to.  If not null, *LOADBASEP is filled in with the difference
8794    between the VMAs from which the segments were read, and the VMAs the
8795    file headers (and hence BFD's idea of each section's VMA) put them at.
8796
8797    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8798    remote memory at target address VMA into the local buffer at MYADDR; it
8799    should return zero on success or an `errno' code on failure.  TEMPL must
8800    be a BFD for an ELF target with the word size and byte order found in
8801    the remote memory.  */
8802
8803 bfd *
8804 bfd_elf_bfd_from_remote_memory
8805   (bfd *templ,
8806    bfd_vma ehdr_vma,
8807    bfd_vma *loadbasep,
8808    int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8809 {
8810   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8811     (templ, ehdr_vma, loadbasep, target_read_memory);
8812 }
8813 \f
8814 long
8815 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8816                                long symcount ATTRIBUTE_UNUSED,
8817                                asymbol **syms ATTRIBUTE_UNUSED,
8818                                long dynsymcount,
8819                                asymbol **dynsyms,
8820                                asymbol **ret)
8821 {
8822   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8823   asection *relplt;
8824   asymbol *s;
8825   const char *relplt_name;
8826   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8827   arelent *p;
8828   long count, i, n;
8829   size_t size;
8830   Elf_Internal_Shdr *hdr;
8831   char *names;
8832   asection *plt;
8833
8834   *ret = NULL;
8835
8836   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8837     return 0;
8838
8839   if (dynsymcount <= 0)
8840     return 0;
8841
8842   if (!bed->plt_sym_val)
8843     return 0;
8844
8845   relplt_name = bed->relplt_name;
8846   if (relplt_name == NULL)
8847     relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
8848   relplt = bfd_get_section_by_name (abfd, relplt_name);
8849   if (relplt == NULL)
8850     return 0;
8851
8852   hdr = &elf_section_data (relplt)->this_hdr;
8853   if (hdr->sh_link != elf_dynsymtab (abfd)
8854       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8855     return 0;
8856
8857   plt = bfd_get_section_by_name (abfd, ".plt");
8858   if (plt == NULL)
8859     return 0;
8860
8861   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8862   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8863     return -1;
8864
8865   count = relplt->size / hdr->sh_entsize;
8866   size = count * sizeof (asymbol);
8867   p = relplt->relocation;
8868   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
8869     size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8870
8871   s = *ret = bfd_malloc (size);
8872   if (s == NULL)
8873     return -1;
8874
8875   names = (char *) (s + count);
8876   p = relplt->relocation;
8877   n = 0;
8878   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
8879     {
8880       size_t len;
8881       bfd_vma addr;
8882
8883       addr = bed->plt_sym_val (i, plt, p);
8884       if (addr == (bfd_vma) -1)
8885         continue;
8886
8887       *s = **p->sym_ptr_ptr;
8888       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
8889          we are defining a symbol, ensure one of them is set.  */
8890       if ((s->flags & BSF_LOCAL) == 0)
8891         s->flags |= BSF_GLOBAL;
8892       s->flags |= BSF_SYNTHETIC;
8893       s->section = plt;
8894       s->value = addr - plt->vma;
8895       s->name = names;
8896       s->udata.p = NULL;
8897       len = strlen ((*p->sym_ptr_ptr)->name);
8898       memcpy (names, (*p->sym_ptr_ptr)->name, len);
8899       names += len;
8900       memcpy (names, "@plt", sizeof ("@plt"));
8901       names += sizeof ("@plt");
8902       ++s, ++n;
8903     }
8904
8905   return n;
8906 }
8907
8908 /* It is only used by x86-64 so far.  */
8909 asection _bfd_elf_large_com_section
8910   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
8911                       SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
8912
8913 void
8914 _bfd_elf_set_osabi (bfd * abfd,
8915                     struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
8916 {
8917   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
8918
8919   i_ehdrp = elf_elfheader (abfd);
8920
8921   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
8922 }
8923
8924
8925 /* Return TRUE for ELF symbol types that represent functions.
8926    This is the default version of this function, which is sufficient for
8927    most targets.  It returns true if TYPE is STT_FUNC.  */
8928
8929 bfd_boolean
8930 _bfd_elf_is_function_type (unsigned int type)
8931 {
8932   return (type == STT_FUNC);
8933 }