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