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 #else
6464             sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6465 #endif
6466         }
6467       else if (bfd_is_und_section (syms[idx]->section))
6468         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6469                                     ? STB_WEAK
6470                                     : STB_GLOBAL),
6471                                    type);
6472       else if (flags & BSF_FILE)
6473         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6474       else
6475         {
6476           int bind = STB_LOCAL;
6477
6478           if (flags & BSF_LOCAL)
6479             bind = STB_LOCAL;
6480           else if (flags & BSF_WEAK)
6481             bind = STB_WEAK;
6482           else if (flags & BSF_GLOBAL)
6483             bind = STB_GLOBAL;
6484
6485           sym.st_info = ELF_ST_INFO (bind, type);
6486         }
6487
6488       if (type_ptr != NULL)
6489         sym.st_other = type_ptr->internal_elf_sym.st_other;
6490       else
6491         sym.st_other = 0;
6492
6493       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6494       outbound_syms += bed->s->sizeof_sym;
6495       if (outbound_shndx != NULL)
6496         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6497     }
6498
6499   *sttp = stt;
6500   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6501   symstrtab_hdr->sh_type = SHT_STRTAB;
6502
6503   symstrtab_hdr->sh_flags = 0;
6504   symstrtab_hdr->sh_addr = 0;
6505   symstrtab_hdr->sh_entsize = 0;
6506   symstrtab_hdr->sh_link = 0;
6507   symstrtab_hdr->sh_info = 0;
6508   symstrtab_hdr->sh_addralign = 1;
6509
6510   return TRUE;
6511 }
6512
6513 /* Return the number of bytes required to hold the symtab vector.
6514
6515    Note that we base it on the count plus 1, since we will null terminate
6516    the vector allocated based on this size.  However, the ELF symbol table
6517    always has a dummy entry as symbol #0, so it ends up even.  */
6518
6519 long
6520 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6521 {
6522   long symcount;
6523   long symtab_size;
6524   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6525
6526   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6527   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6528   if (symcount > 0)
6529     symtab_size -= sizeof (asymbol *);
6530
6531   return symtab_size;
6532 }
6533
6534 long
6535 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6536 {
6537   long symcount;
6538   long symtab_size;
6539   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6540
6541   if (elf_dynsymtab (abfd) == 0)
6542     {
6543       bfd_set_error (bfd_error_invalid_operation);
6544       return -1;
6545     }
6546
6547   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6548   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6549   if (symcount > 0)
6550     symtab_size -= sizeof (asymbol *);
6551
6552   return symtab_size;
6553 }
6554
6555 long
6556 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6557                                 sec_ptr asect)
6558 {
6559   return (asect->reloc_count + 1) * sizeof (arelent *);
6560 }
6561
6562 /* Canonicalize the relocs.  */
6563
6564 long
6565 _bfd_elf_canonicalize_reloc (bfd *abfd,
6566                              sec_ptr section,
6567                              arelent **relptr,
6568                              asymbol **symbols)
6569 {
6570   arelent *tblptr;
6571   unsigned int i;
6572   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6573
6574   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6575     return -1;
6576
6577   tblptr = section->relocation;
6578   for (i = 0; i < section->reloc_count; i++)
6579     *relptr++ = tblptr++;
6580
6581   *relptr = NULL;
6582
6583   return section->reloc_count;
6584 }
6585
6586 long
6587 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6588 {
6589   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6590   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6591
6592   if (symcount >= 0)
6593     bfd_get_symcount (abfd) = symcount;
6594   return symcount;
6595 }
6596
6597 long
6598 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6599                                       asymbol **allocation)
6600 {
6601   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6602   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6603
6604   if (symcount >= 0)
6605     bfd_get_dynamic_symcount (abfd) = symcount;
6606   return symcount;
6607 }
6608
6609 /* Return the size required for the dynamic reloc entries.  Any loadable
6610    section that was actually installed in the BFD, and has type SHT_REL
6611    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6612    dynamic reloc section.  */
6613
6614 long
6615 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6616 {
6617   long ret;
6618   asection *s;
6619
6620   if (elf_dynsymtab (abfd) == 0)
6621     {
6622       bfd_set_error (bfd_error_invalid_operation);
6623       return -1;
6624     }
6625
6626   ret = sizeof (arelent *);
6627   for (s = abfd->sections; s != NULL; s = s->next)
6628     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6629         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6630             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6631       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6632               * sizeof (arelent *));
6633
6634   return ret;
6635 }
6636
6637 /* Canonicalize the dynamic relocation entries.  Note that we return the
6638    dynamic relocations as a single block, although they are actually
6639    associated with particular sections; the interface, which was
6640    designed for SunOS style shared libraries, expects that there is only
6641    one set of dynamic relocs.  Any loadable section that was actually
6642    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6643    dynamic symbol table, is considered to be a dynamic reloc section.  */
6644
6645 long
6646 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6647                                      arelent **storage,
6648                                      asymbol **syms)
6649 {
6650   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6651   asection *s;
6652   long ret;
6653
6654   if (elf_dynsymtab (abfd) == 0)
6655     {
6656       bfd_set_error (bfd_error_invalid_operation);
6657       return -1;
6658     }
6659
6660   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6661   ret = 0;
6662   for (s = abfd->sections; s != NULL; s = s->next)
6663     {
6664       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6665           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6666               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6667         {
6668           arelent *p;
6669           long count, i;
6670
6671           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6672             return -1;
6673           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6674           p = s->relocation;
6675           for (i = 0; i < count; i++)
6676             *storage++ = p++;
6677           ret += count;
6678         }
6679     }
6680
6681   *storage = NULL;
6682
6683   return ret;
6684 }
6685 \f
6686 /* Read in the version information.  */
6687
6688 bfd_boolean
6689 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6690 {
6691   bfd_byte *contents = NULL;
6692   unsigned int freeidx = 0;
6693
6694   if (elf_dynverref (abfd) != 0)
6695     {
6696       Elf_Internal_Shdr *hdr;
6697       Elf_External_Verneed *everneed;
6698       Elf_Internal_Verneed *iverneed;
6699       unsigned int i;
6700       bfd_byte *contents_end;
6701
6702       hdr = &elf_tdata (abfd)->dynverref_hdr;
6703
6704       elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6705                                               sizeof (Elf_Internal_Verneed));
6706       if (elf_tdata (abfd)->verref == NULL)
6707         goto error_return;
6708
6709       elf_tdata (abfd)->cverrefs = hdr->sh_info;
6710
6711       contents = bfd_malloc (hdr->sh_size);
6712       if (contents == NULL)
6713         {
6714 error_return_verref:
6715           elf_tdata (abfd)->verref = NULL;
6716           elf_tdata (abfd)->cverrefs = 0;
6717           goto error_return;
6718         }
6719       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6720           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6721         goto error_return_verref;
6722
6723       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6724         goto error_return_verref;
6725
6726       BFD_ASSERT (sizeof (Elf_External_Verneed)
6727                   == sizeof (Elf_External_Vernaux));
6728       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6729       everneed = (Elf_External_Verneed *) contents;
6730       iverneed = elf_tdata (abfd)->verref;
6731       for (i = 0; i < hdr->sh_info; i++, iverneed++)
6732         {
6733           Elf_External_Vernaux *evernaux;
6734           Elf_Internal_Vernaux *ivernaux;
6735           unsigned int j;
6736
6737           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6738
6739           iverneed->vn_bfd = abfd;
6740
6741           iverneed->vn_filename =
6742             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6743                                              iverneed->vn_file);
6744           if (iverneed->vn_filename == NULL)
6745             goto error_return_verref;
6746
6747           if (iverneed->vn_cnt == 0)
6748             iverneed->vn_auxptr = NULL;
6749           else
6750             {
6751               iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6752                                                 sizeof (Elf_Internal_Vernaux));
6753               if (iverneed->vn_auxptr == NULL)
6754                 goto error_return_verref;
6755             }
6756
6757           if (iverneed->vn_aux
6758               > (size_t) (contents_end - (bfd_byte *) everneed))
6759             goto error_return_verref;
6760
6761           evernaux = ((Elf_External_Vernaux *)
6762                       ((bfd_byte *) everneed + iverneed->vn_aux));
6763           ivernaux = iverneed->vn_auxptr;
6764           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6765             {
6766               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6767
6768               ivernaux->vna_nodename =
6769                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6770                                                  ivernaux->vna_name);
6771               if (ivernaux->vna_nodename == NULL)
6772                 goto error_return_verref;
6773
6774               if (j + 1 < iverneed->vn_cnt)
6775                 ivernaux->vna_nextptr = ivernaux + 1;
6776               else
6777                 ivernaux->vna_nextptr = NULL;
6778
6779               if (ivernaux->vna_next
6780                   > (size_t) (contents_end - (bfd_byte *) evernaux))
6781                 goto error_return_verref;
6782
6783               evernaux = ((Elf_External_Vernaux *)
6784                           ((bfd_byte *) evernaux + ivernaux->vna_next));
6785
6786               if (ivernaux->vna_other > freeidx)
6787                 freeidx = ivernaux->vna_other;
6788             }
6789
6790           if (i + 1 < hdr->sh_info)
6791             iverneed->vn_nextref = iverneed + 1;
6792           else
6793             iverneed->vn_nextref = NULL;
6794
6795           if (iverneed->vn_next
6796               > (size_t) (contents_end - (bfd_byte *) everneed))
6797             goto error_return_verref;
6798
6799           everneed = ((Elf_External_Verneed *)
6800                       ((bfd_byte *) everneed + iverneed->vn_next));
6801         }
6802
6803       free (contents);
6804       contents = NULL;
6805     }
6806
6807   if (elf_dynverdef (abfd) != 0)
6808     {
6809       Elf_Internal_Shdr *hdr;
6810       Elf_External_Verdef *everdef;
6811       Elf_Internal_Verdef *iverdef;
6812       Elf_Internal_Verdef *iverdefarr;
6813       Elf_Internal_Verdef iverdefmem;
6814       unsigned int i;
6815       unsigned int maxidx;
6816       bfd_byte *contents_end_def, *contents_end_aux;
6817
6818       hdr = &elf_tdata (abfd)->dynverdef_hdr;
6819
6820       contents = bfd_malloc (hdr->sh_size);
6821       if (contents == NULL)
6822         goto error_return;
6823       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6824           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6825         goto error_return;
6826
6827       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6828         goto error_return;
6829
6830       BFD_ASSERT (sizeof (Elf_External_Verdef)
6831                   >= sizeof (Elf_External_Verdaux));
6832       contents_end_def = contents + hdr->sh_size
6833                          - sizeof (Elf_External_Verdef);
6834       contents_end_aux = contents + hdr->sh_size
6835                          - sizeof (Elf_External_Verdaux);
6836
6837       /* We know the number of entries in the section but not the maximum
6838          index.  Therefore we have to run through all entries and find
6839          the maximum.  */
6840       everdef = (Elf_External_Verdef *) contents;
6841       maxidx = 0;
6842       for (i = 0; i < hdr->sh_info; ++i)
6843         {
6844           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6845
6846           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6847             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6848
6849           if (iverdefmem.vd_next
6850               > (size_t) (contents_end_def - (bfd_byte *) everdef))
6851             goto error_return;
6852
6853           everdef = ((Elf_External_Verdef *)
6854                      ((bfd_byte *) everdef + iverdefmem.vd_next));
6855         }
6856
6857       if (default_imported_symver)
6858         {
6859           if (freeidx > maxidx)
6860             maxidx = ++freeidx;
6861           else
6862             freeidx = ++maxidx;
6863         }
6864       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6865                                               sizeof (Elf_Internal_Verdef));
6866       if (elf_tdata (abfd)->verdef == NULL)
6867         goto error_return;
6868
6869       elf_tdata (abfd)->cverdefs = maxidx;
6870
6871       everdef = (Elf_External_Verdef *) contents;
6872       iverdefarr = elf_tdata (abfd)->verdef;
6873       for (i = 0; i < hdr->sh_info; i++)
6874         {
6875           Elf_External_Verdaux *everdaux;
6876           Elf_Internal_Verdaux *iverdaux;
6877           unsigned int j;
6878
6879           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6880
6881           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6882             {
6883 error_return_verdef:
6884               elf_tdata (abfd)->verdef = NULL;
6885               elf_tdata (abfd)->cverdefs = 0;
6886               goto error_return;
6887             }
6888
6889           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6890           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6891
6892           iverdef->vd_bfd = abfd;
6893
6894           if (iverdef->vd_cnt == 0)
6895             iverdef->vd_auxptr = NULL;
6896           else
6897             {
6898               iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6899                                                sizeof (Elf_Internal_Verdaux));
6900               if (iverdef->vd_auxptr == NULL)
6901                 goto error_return_verdef;
6902             }
6903
6904           if (iverdef->vd_aux
6905               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6906             goto error_return_verdef;
6907
6908           everdaux = ((Elf_External_Verdaux *)
6909                       ((bfd_byte *) everdef + iverdef->vd_aux));
6910           iverdaux = iverdef->vd_auxptr;
6911           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6912             {
6913               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6914
6915               iverdaux->vda_nodename =
6916                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6917                                                  iverdaux->vda_name);
6918               if (iverdaux->vda_nodename == NULL)
6919                 goto error_return_verdef;
6920
6921               if (j + 1 < iverdef->vd_cnt)
6922                 iverdaux->vda_nextptr = iverdaux + 1;
6923               else
6924                 iverdaux->vda_nextptr = NULL;
6925
6926               if (iverdaux->vda_next
6927                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6928                 goto error_return_verdef;
6929
6930               everdaux = ((Elf_External_Verdaux *)
6931                           ((bfd_byte *) everdaux + iverdaux->vda_next));
6932             }
6933
6934           if (iverdef->vd_cnt)
6935             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6936
6937           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
6938             iverdef->vd_nextdef = iverdef + 1;
6939           else
6940             iverdef->vd_nextdef = NULL;
6941
6942           everdef = ((Elf_External_Verdef *)
6943                      ((bfd_byte *) everdef + iverdef->vd_next));
6944         }
6945
6946       free (contents);
6947       contents = NULL;
6948     }
6949   else if (default_imported_symver)
6950     {
6951       if (freeidx < 3)
6952         freeidx = 3;
6953       else
6954         freeidx++;
6955
6956       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6957                                               sizeof (Elf_Internal_Verdef));
6958       if (elf_tdata (abfd)->verdef == NULL)
6959         goto error_return;
6960
6961       elf_tdata (abfd)->cverdefs = freeidx;
6962     }
6963
6964   /* Create a default version based on the soname.  */
6965   if (default_imported_symver)
6966     {
6967       Elf_Internal_Verdef *iverdef;
6968       Elf_Internal_Verdaux *iverdaux;
6969
6970       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6971
6972       iverdef->vd_version = VER_DEF_CURRENT;
6973       iverdef->vd_flags = 0;
6974       iverdef->vd_ndx = freeidx;
6975       iverdef->vd_cnt = 1;
6976
6977       iverdef->vd_bfd = abfd;
6978
6979       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6980       if (iverdef->vd_nodename == NULL)
6981         goto error_return_verdef;
6982       iverdef->vd_nextdef = NULL;
6983       iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6984       if (iverdef->vd_auxptr == NULL)
6985         goto error_return_verdef;
6986
6987       iverdaux = iverdef->vd_auxptr;
6988       iverdaux->vda_nodename = iverdef->vd_nodename;
6989       iverdaux->vda_nextptr = NULL;
6990     }
6991
6992   return TRUE;
6993
6994  error_return:
6995   if (contents != NULL)
6996     free (contents);
6997   return FALSE;
6998 }
6999 \f
7000 asymbol *
7001 _bfd_elf_make_empty_symbol (bfd *abfd)
7002 {
7003   elf_symbol_type *newsym;
7004   bfd_size_type amt = sizeof (elf_symbol_type);
7005
7006   newsym = bfd_zalloc (abfd, amt);
7007   if (!newsym)
7008     return NULL;
7009   else
7010     {
7011       newsym->symbol.the_bfd = abfd;
7012       return &newsym->symbol;
7013     }
7014 }
7015
7016 void
7017 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7018                           asymbol *symbol,
7019                           symbol_info *ret)
7020 {
7021   bfd_symbol_info (symbol, ret);
7022 }
7023
7024 /* Return whether a symbol name implies a local symbol.  Most targets
7025    use this function for the is_local_label_name entry point, but some
7026    override it.  */
7027
7028 bfd_boolean
7029 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7030                               const char *name)
7031 {
7032   /* Normal local symbols start with ``.L''.  */
7033   if (name[0] == '.' && name[1] == 'L')
7034     return TRUE;
7035
7036   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7037      DWARF debugging symbols starting with ``..''.  */
7038   if (name[0] == '.' && name[1] == '.')
7039     return TRUE;
7040
7041   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7042      emitting DWARF debugging output.  I suspect this is actually a
7043      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7044      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7045      underscore to be emitted on some ELF targets).  For ease of use,
7046      we treat such symbols as local.  */
7047   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
7048     return TRUE;
7049
7050   return FALSE;
7051 }
7052
7053 alent *
7054 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7055                      asymbol *symbol ATTRIBUTE_UNUSED)
7056 {
7057   abort ();
7058   return NULL;
7059 }
7060
7061 bfd_boolean
7062 _bfd_elf_set_arch_mach (bfd *abfd,
7063                         enum bfd_architecture arch,
7064                         unsigned long machine)
7065 {
7066   /* If this isn't the right architecture for this backend, and this
7067      isn't the generic backend, fail.  */
7068   if (arch != get_elf_backend_data (abfd)->arch
7069       && arch != bfd_arch_unknown
7070       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
7071     return FALSE;
7072
7073   return bfd_default_set_arch_mach (abfd, arch, machine);
7074 }
7075
7076 /* Find the function to a particular section and offset,
7077    for error reporting.  */
7078
7079 static bfd_boolean
7080 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
7081                    asection *section,
7082                    asymbol **symbols,
7083                    bfd_vma offset,
7084                    const char **filename_ptr,
7085                    const char **functionname_ptr)
7086 {
7087   const char *filename;
7088   asymbol *func, *file;
7089   bfd_vma low_func;
7090   asymbol **p;
7091   /* ??? Given multiple file symbols, it is impossible to reliably
7092      choose the right file name for global symbols.  File symbols are
7093      local symbols, and thus all file symbols must sort before any
7094      global symbols.  The ELF spec may be interpreted to say that a
7095      file symbol must sort before other local symbols, but currently
7096      ld -r doesn't do this.  So, for ld -r output, it is possible to
7097      make a better choice of file name for local symbols by ignoring
7098      file symbols appearing after a given local symbol.  */
7099   enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7100
7101   filename = NULL;
7102   func = NULL;
7103   file = NULL;
7104   low_func = 0;
7105   state = nothing_seen;
7106
7107   for (p = symbols; *p != NULL; p++)
7108     {
7109       elf_symbol_type *q;
7110
7111       q = (elf_symbol_type *) *p;
7112
7113       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7114         {
7115         default:
7116           break;
7117         case STT_FILE:
7118           file = &q->symbol;
7119           if (state == symbol_seen)
7120             state = file_after_symbol_seen;
7121           continue;
7122         case STT_NOTYPE:
7123         case STT_FUNC:
7124           if (bfd_get_section (&q->symbol) == section
7125               && q->symbol.value >= low_func
7126               && q->symbol.value <= offset)
7127             {
7128               func = (asymbol *) q;
7129               low_func = q->symbol.value;
7130               filename = NULL;
7131               if (file != NULL
7132                   && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
7133                       || state != file_after_symbol_seen))
7134                 filename = bfd_asymbol_name (file);
7135             }
7136           break;
7137         }
7138       if (state == nothing_seen)
7139         state = symbol_seen;
7140     }
7141
7142   if (func == NULL)
7143     return FALSE;
7144
7145   if (filename_ptr)
7146     *filename_ptr = filename;
7147   if (functionname_ptr)
7148     *functionname_ptr = bfd_asymbol_name (func);
7149
7150   return TRUE;
7151 }
7152
7153 /* Find the nearest line to a particular section and offset,
7154    for error reporting.  */
7155
7156 bfd_boolean
7157 _bfd_elf_find_nearest_line (bfd *abfd,
7158                             asection *section,
7159                             asymbol **symbols,
7160                             bfd_vma offset,
7161                             const char **filename_ptr,
7162                             const char **functionname_ptr,
7163                             unsigned int *line_ptr)
7164 {
7165   bfd_boolean found;
7166
7167   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7168                                      filename_ptr, functionname_ptr,
7169                                      line_ptr))
7170     {
7171       if (!*functionname_ptr)
7172         elf_find_function (abfd, section, symbols, offset,
7173                            *filename_ptr ? NULL : filename_ptr,
7174                            functionname_ptr);
7175
7176       return TRUE;
7177     }
7178
7179   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7180                                      filename_ptr, functionname_ptr,
7181                                      line_ptr, 0,
7182                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7183     {
7184       if (!*functionname_ptr)
7185         elf_find_function (abfd, section, symbols, offset,
7186                            *filename_ptr ? NULL : filename_ptr,
7187                            functionname_ptr);
7188
7189       return TRUE;
7190     }
7191
7192   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7193                                              &found, filename_ptr,
7194                                              functionname_ptr, line_ptr,
7195                                              &elf_tdata (abfd)->line_info))
7196     return FALSE;
7197   if (found && (*functionname_ptr || *line_ptr))
7198     return TRUE;
7199
7200   if (symbols == NULL)
7201     return FALSE;
7202
7203   if (! elf_find_function (abfd, section, symbols, offset,
7204                            filename_ptr, functionname_ptr))
7205     return FALSE;
7206
7207   *line_ptr = 0;
7208   return TRUE;
7209 }
7210
7211 /* Find the line for a symbol.  */
7212
7213 bfd_boolean
7214 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7215                     const char **filename_ptr, unsigned int *line_ptr)
7216 {
7217   return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7218                                 filename_ptr, line_ptr, 0,
7219                                 &elf_tdata (abfd)->dwarf2_find_line_info);
7220 }
7221
7222 /* After a call to bfd_find_nearest_line, successive calls to
7223    bfd_find_inliner_info can be used to get source information about
7224    each level of function inlining that terminated at the address
7225    passed to bfd_find_nearest_line.  Currently this is only supported
7226    for DWARF2 with appropriate DWARF3 extensions. */
7227
7228 bfd_boolean
7229 _bfd_elf_find_inliner_info (bfd *abfd,
7230                             const char **filename_ptr,
7231                             const char **functionname_ptr,
7232                             unsigned int *line_ptr)
7233 {
7234   bfd_boolean found;
7235   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7236                                          functionname_ptr, line_ptr,
7237                                          & elf_tdata (abfd)->dwarf2_find_line_info);
7238   return found;
7239 }
7240
7241 int
7242 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7243 {
7244   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7245   int ret = bed->s->sizeof_ehdr;
7246
7247   if (!info->relocatable)
7248     {
7249       bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7250
7251       if (phdr_size == (bfd_size_type) -1)
7252         {
7253           struct elf_segment_map *m;
7254
7255           phdr_size = 0;
7256           for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7257             phdr_size += bed->s->sizeof_phdr;
7258
7259           if (phdr_size == 0)
7260             phdr_size = get_program_header_size (abfd, info);
7261         }
7262
7263       elf_tdata (abfd)->program_header_size = phdr_size;
7264       ret += phdr_size;
7265     }
7266
7267   return ret;
7268 }
7269
7270 bfd_boolean
7271 _bfd_elf_set_section_contents (bfd *abfd,
7272                                sec_ptr section,
7273                                const void *location,
7274                                file_ptr offset,
7275                                bfd_size_type count)
7276 {
7277   Elf_Internal_Shdr *hdr;
7278   bfd_signed_vma pos;
7279
7280   if (! abfd->output_has_begun
7281       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7282     return FALSE;
7283
7284   hdr = &elf_section_data (section)->this_hdr;
7285   pos = hdr->sh_offset + offset;
7286   if (bfd_seek (abfd, pos, SEEK_SET) != 0
7287       || bfd_bwrite (location, count, abfd) != count)
7288     return FALSE;
7289
7290   return TRUE;
7291 }
7292
7293 void
7294 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7295                            arelent *cache_ptr ATTRIBUTE_UNUSED,
7296                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7297 {
7298   abort ();
7299 }
7300
7301 /* Try to convert a non-ELF reloc into an ELF one.  */
7302
7303 bfd_boolean
7304 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7305 {
7306   /* Check whether we really have an ELF howto.  */
7307
7308   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7309     {
7310       bfd_reloc_code_real_type code;
7311       reloc_howto_type *howto;
7312
7313       /* Alien reloc: Try to determine its type to replace it with an
7314          equivalent ELF reloc.  */
7315
7316       if (areloc->howto->pc_relative)
7317         {
7318           switch (areloc->howto->bitsize)
7319             {
7320             case 8:
7321               code = BFD_RELOC_8_PCREL;
7322               break;
7323             case 12:
7324               code = BFD_RELOC_12_PCREL;
7325               break;
7326             case 16:
7327               code = BFD_RELOC_16_PCREL;
7328               break;
7329             case 24:
7330               code = BFD_RELOC_24_PCREL;
7331               break;
7332             case 32:
7333               code = BFD_RELOC_32_PCREL;
7334               break;
7335             case 64:
7336               code = BFD_RELOC_64_PCREL;
7337               break;
7338             default:
7339               goto fail;
7340             }
7341
7342           howto = bfd_reloc_type_lookup (abfd, code);
7343
7344           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7345             {
7346               if (howto->pcrel_offset)
7347                 areloc->addend += areloc->address;
7348               else
7349                 areloc->addend -= areloc->address; /* addend is unsigned!! */
7350             }
7351         }
7352       else
7353         {
7354           switch (areloc->howto->bitsize)
7355             {
7356             case 8:
7357               code = BFD_RELOC_8;
7358               break;
7359             case 14:
7360               code = BFD_RELOC_14;
7361               break;
7362             case 16:
7363               code = BFD_RELOC_16;
7364               break;
7365             case 26:
7366               code = BFD_RELOC_26;
7367               break;
7368             case 32:
7369               code = BFD_RELOC_32;
7370               break;
7371             case 64:
7372               code = BFD_RELOC_64;
7373               break;
7374             default:
7375               goto fail;
7376             }
7377
7378           howto = bfd_reloc_type_lookup (abfd, code);
7379         }
7380
7381       if (howto)
7382         areloc->howto = howto;
7383       else
7384         goto fail;
7385     }
7386
7387   return TRUE;
7388
7389  fail:
7390   (*_bfd_error_handler)
7391     (_("%B: unsupported relocation type %s"),
7392      abfd, areloc->howto->name);
7393   bfd_set_error (bfd_error_bad_value);
7394   return FALSE;
7395 }
7396
7397 bfd_boolean
7398 _bfd_elf_close_and_cleanup (bfd *abfd)
7399 {
7400   if (bfd_get_format (abfd) == bfd_object)
7401     {
7402       if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
7403         _bfd_elf_strtab_free (elf_shstrtab (abfd));
7404       _bfd_dwarf2_cleanup_debug_info (abfd);
7405     }
7406
7407   return _bfd_generic_close_and_cleanup (abfd);
7408 }
7409
7410 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7411    in the relocation's offset.  Thus we cannot allow any sort of sanity
7412    range-checking to interfere.  There is nothing else to do in processing
7413    this reloc.  */
7414
7415 bfd_reloc_status_type
7416 _bfd_elf_rel_vtable_reloc_fn
7417   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7418    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7419    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7420    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7421 {
7422   return bfd_reloc_ok;
7423 }
7424 \f
7425 /* Elf core file support.  Much of this only works on native
7426    toolchains, since we rely on knowing the
7427    machine-dependent procfs structure in order to pick
7428    out details about the corefile.  */
7429
7430 #ifdef HAVE_SYS_PROCFS_H
7431 # include <sys/procfs.h>
7432 #endif
7433
7434 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
7435
7436 static int
7437 elfcore_make_pid (bfd *abfd)
7438 {
7439   return ((elf_tdata (abfd)->core_lwpid << 16)
7440           + (elf_tdata (abfd)->core_pid));
7441 }
7442
7443 /* If there isn't a section called NAME, make one, using
7444    data from SECT.  Note, this function will generate a
7445    reference to NAME, so you shouldn't deallocate or
7446    overwrite it.  */
7447
7448 static bfd_boolean
7449 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7450 {
7451   asection *sect2;
7452
7453   if (bfd_get_section_by_name (abfd, name) != NULL)
7454     return TRUE;
7455
7456   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7457   if (sect2 == NULL)
7458     return FALSE;
7459
7460   sect2->size = sect->size;
7461   sect2->filepos = sect->filepos;
7462   sect2->alignment_power = sect->alignment_power;
7463   return TRUE;
7464 }
7465
7466 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
7467    actually creates up to two pseudosections:
7468    - For the single-threaded case, a section named NAME, unless
7469      such a section already exists.
7470    - For the multi-threaded case, a section named "NAME/PID", where
7471      PID is elfcore_make_pid (abfd).
7472    Both pseudosections have identical contents. */
7473 bfd_boolean
7474 _bfd_elfcore_make_pseudosection (bfd *abfd,
7475                                  char *name,
7476                                  size_t size,
7477                                  ufile_ptr filepos)
7478 {
7479   char buf[100];
7480   char *threaded_name;
7481   size_t len;
7482   asection *sect;
7483
7484   /* Build the section name.  */
7485
7486   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7487   len = strlen (buf) + 1;
7488   threaded_name = bfd_alloc (abfd, len);
7489   if (threaded_name == NULL)
7490     return FALSE;
7491   memcpy (threaded_name, buf, len);
7492
7493   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7494                                              SEC_HAS_CONTENTS);
7495   if (sect == NULL)
7496     return FALSE;
7497   sect->size = size;
7498   sect->filepos = filepos;
7499   sect->alignment_power = 2;
7500
7501   return elfcore_maybe_make_sect (abfd, name, sect);
7502 }
7503
7504 /* prstatus_t exists on:
7505      solaris 2.5+
7506      linux 2.[01] + glibc
7507      unixware 4.2
7508 */
7509
7510 #if defined (HAVE_PRSTATUS_T)
7511
7512 static bfd_boolean
7513 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7514 {
7515   size_t size;
7516   int offset;
7517
7518   if (note->descsz == sizeof (prstatus_t))
7519     {
7520       prstatus_t prstat;
7521
7522       size = sizeof (prstat.pr_reg);
7523       offset   = offsetof (prstatus_t, pr_reg);
7524       memcpy (&prstat, note->descdata, sizeof (prstat));
7525
7526       /* Do not overwrite the core signal if it
7527          has already been set by another thread.  */
7528       if (elf_tdata (abfd)->core_signal == 0)
7529         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7530       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7531
7532       /* pr_who exists on:
7533          solaris 2.5+
7534          unixware 4.2
7535          pr_who doesn't exist on:
7536          linux 2.[01]
7537          */
7538 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7539       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7540 #endif
7541     }
7542 #if defined (HAVE_PRSTATUS32_T)
7543   else if (note->descsz == sizeof (prstatus32_t))
7544     {
7545       /* 64-bit host, 32-bit corefile */
7546       prstatus32_t prstat;
7547
7548       size = sizeof (prstat.pr_reg);
7549       offset   = offsetof (prstatus32_t, pr_reg);
7550       memcpy (&prstat, note->descdata, sizeof (prstat));
7551
7552       /* Do not overwrite the core signal if it
7553          has already been set by another thread.  */
7554       if (elf_tdata (abfd)->core_signal == 0)
7555         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7556       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7557
7558       /* pr_who exists on:
7559          solaris 2.5+
7560          unixware 4.2
7561          pr_who doesn't exist on:
7562          linux 2.[01]
7563          */
7564 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7565       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7566 #endif
7567     }
7568 #endif /* HAVE_PRSTATUS32_T */
7569   else
7570     {
7571       /* Fail - we don't know how to handle any other
7572          note size (ie. data object type).  */
7573       return TRUE;
7574     }
7575
7576   /* Make a ".reg/999" section and a ".reg" section.  */
7577   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7578                                           size, note->descpos + offset);
7579 }
7580 #endif /* defined (HAVE_PRSTATUS_T) */
7581
7582 /* Create a pseudosection containing the exact contents of NOTE.  */
7583 static bfd_boolean
7584 elfcore_make_note_pseudosection (bfd *abfd,
7585                                  char *name,
7586                                  Elf_Internal_Note *note)
7587 {
7588   return _bfd_elfcore_make_pseudosection (abfd, name,
7589                                           note->descsz, note->descpos);
7590 }
7591
7592 /* There isn't a consistent prfpregset_t across platforms,
7593    but it doesn't matter, because we don't have to pick this
7594    data structure apart.  */
7595
7596 static bfd_boolean
7597 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7598 {
7599   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7600 }
7601
7602 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7603    type of NT_PRXFPREG.  Just include the whole note's contents
7604    literally.  */
7605
7606 static bfd_boolean
7607 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7608 {
7609   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7610 }
7611
7612 static bfd_boolean
7613 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
7614 {
7615   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
7616 }
7617
7618 static bfd_boolean
7619 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
7620 {
7621   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
7622 }
7623
7624 #if defined (HAVE_PRPSINFO_T)
7625 typedef prpsinfo_t   elfcore_psinfo_t;
7626 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
7627 typedef prpsinfo32_t elfcore_psinfo32_t;
7628 #endif
7629 #endif
7630
7631 #if defined (HAVE_PSINFO_T)
7632 typedef psinfo_t   elfcore_psinfo_t;
7633 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
7634 typedef psinfo32_t elfcore_psinfo32_t;
7635 #endif
7636 #endif
7637
7638 /* return a malloc'ed copy of a string at START which is at
7639    most MAX bytes long, possibly without a terminating '\0'.
7640    the copy will always have a terminating '\0'.  */
7641
7642 char *
7643 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7644 {
7645   char *dups;
7646   char *end = memchr (start, '\0', max);
7647   size_t len;
7648
7649   if (end == NULL)
7650     len = max;
7651   else
7652     len = end - start;
7653
7654   dups = bfd_alloc (abfd, len + 1);
7655   if (dups == NULL)
7656     return NULL;
7657
7658   memcpy (dups, start, len);
7659   dups[len] = '\0';
7660
7661   return dups;
7662 }
7663
7664 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7665 static bfd_boolean
7666 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7667 {
7668   if (note->descsz == sizeof (elfcore_psinfo_t))
7669     {
7670       elfcore_psinfo_t psinfo;
7671
7672       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7673
7674       elf_tdata (abfd)->core_program
7675         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7676                                 sizeof (psinfo.pr_fname));
7677
7678       elf_tdata (abfd)->core_command
7679         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7680                                 sizeof (psinfo.pr_psargs));
7681     }
7682 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7683   else if (note->descsz == sizeof (elfcore_psinfo32_t))
7684     {
7685       /* 64-bit host, 32-bit corefile */
7686       elfcore_psinfo32_t psinfo;
7687
7688       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7689
7690       elf_tdata (abfd)->core_program
7691         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7692                                 sizeof (psinfo.pr_fname));
7693
7694       elf_tdata (abfd)->core_command
7695         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7696                                 sizeof (psinfo.pr_psargs));
7697     }
7698 #endif
7699
7700   else
7701     {
7702       /* Fail - we don't know how to handle any other
7703          note size (ie. data object type).  */
7704       return TRUE;
7705     }
7706
7707   /* Note that for some reason, a spurious space is tacked
7708      onto the end of the args in some (at least one anyway)
7709      implementations, so strip it off if it exists.  */
7710
7711   {
7712     char *command = elf_tdata (abfd)->core_command;
7713     int n = strlen (command);
7714
7715     if (0 < n && command[n - 1] == ' ')
7716       command[n - 1] = '\0';
7717   }
7718
7719   return TRUE;
7720 }
7721 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7722
7723 #if defined (HAVE_PSTATUS_T)
7724 static bfd_boolean
7725 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7726 {
7727   if (note->descsz == sizeof (pstatus_t)
7728 #if defined (HAVE_PXSTATUS_T)
7729       || note->descsz == sizeof (pxstatus_t)
7730 #endif
7731       )
7732     {
7733       pstatus_t pstat;
7734
7735       memcpy (&pstat, note->descdata, sizeof (pstat));
7736
7737       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7738     }
7739 #if defined (HAVE_PSTATUS32_T)
7740   else if (note->descsz == sizeof (pstatus32_t))
7741     {
7742       /* 64-bit host, 32-bit corefile */
7743       pstatus32_t pstat;
7744
7745       memcpy (&pstat, note->descdata, sizeof (pstat));
7746
7747       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7748     }
7749 #endif
7750   /* Could grab some more details from the "representative"
7751      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7752      NT_LWPSTATUS note, presumably.  */
7753
7754   return TRUE;
7755 }
7756 #endif /* defined (HAVE_PSTATUS_T) */
7757
7758 #if defined (HAVE_LWPSTATUS_T)
7759 static bfd_boolean
7760 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7761 {
7762   lwpstatus_t lwpstat;
7763   char buf[100];
7764   char *name;
7765   size_t len;
7766   asection *sect;
7767
7768   if (note->descsz != sizeof (lwpstat)
7769 #if defined (HAVE_LWPXSTATUS_T)
7770       && note->descsz != sizeof (lwpxstatus_t)
7771 #endif
7772       )
7773     return TRUE;
7774
7775   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7776
7777   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7778   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7779
7780   /* Make a ".reg/999" section.  */
7781
7782   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7783   len = strlen (buf) + 1;
7784   name = bfd_alloc (abfd, len);
7785   if (name == NULL)
7786     return FALSE;
7787   memcpy (name, buf, len);
7788
7789   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7790   if (sect == NULL)
7791     return FALSE;
7792
7793 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7794   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7795   sect->filepos = note->descpos
7796     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7797 #endif
7798
7799 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7800   sect->size = sizeof (lwpstat.pr_reg);
7801   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7802 #endif
7803
7804   sect->alignment_power = 2;
7805
7806   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7807     return FALSE;
7808
7809   /* Make a ".reg2/999" section */
7810
7811   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7812   len = strlen (buf) + 1;
7813   name = bfd_alloc (abfd, len);
7814   if (name == NULL)
7815     return FALSE;
7816   memcpy (name, buf, len);
7817
7818   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7819   if (sect == NULL)
7820     return FALSE;
7821
7822 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7823   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7824   sect->filepos = note->descpos
7825     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7826 #endif
7827
7828 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7829   sect->size = sizeof (lwpstat.pr_fpreg);
7830   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7831 #endif
7832
7833   sect->alignment_power = 2;
7834
7835   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7836 }
7837 #endif /* defined (HAVE_LWPSTATUS_T) */
7838
7839 static bfd_boolean
7840 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7841 {
7842   char buf[30];
7843   char *name;
7844   size_t len;
7845   asection *sect;
7846   int type;
7847   int is_active_thread;
7848   bfd_vma base_addr;
7849
7850   if (note->descsz < 728)
7851     return TRUE;
7852
7853   if (! CONST_STRNEQ (note->namedata, "win32"))
7854     return TRUE;
7855
7856   type = bfd_get_32 (abfd, note->descdata);
7857
7858   switch (type)
7859     {
7860     case 1 /* NOTE_INFO_PROCESS */:
7861       /* FIXME: need to add ->core_command.  */
7862       /* process_info.pid */
7863       elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
7864       /* process_info.signal */
7865       elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
7866       break;
7867
7868     case 2 /* NOTE_INFO_THREAD */:
7869       /* Make a ".reg/999" section.  */
7870       /* thread_info.tid */
7871       sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
7872
7873       len = strlen (buf) + 1;
7874       name = bfd_alloc (abfd, len);
7875       if (name == NULL)
7876         return FALSE;
7877
7878       memcpy (name, buf, len);
7879
7880       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7881       if (sect == NULL)
7882         return FALSE;
7883
7884       /* sizeof (thread_info.thread_context) */
7885       sect->size = 716;
7886       /* offsetof (thread_info.thread_context) */
7887       sect->filepos = note->descpos + 12;
7888       sect->alignment_power = 2;
7889
7890       /* thread_info.is_active_thread */
7891       is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
7892
7893       if (is_active_thread)
7894         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7895           return FALSE;
7896       break;
7897
7898     case 3 /* NOTE_INFO_MODULE */:
7899       /* Make a ".module/xxxxxxxx" section.  */
7900       /* module_info.base_address */
7901       base_addr = bfd_get_32 (abfd, note->descdata + 4);
7902       sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
7903
7904       len = strlen (buf) + 1;
7905       name = bfd_alloc (abfd, len);
7906       if (name == NULL)
7907         return FALSE;
7908
7909       memcpy (name, buf, len);
7910
7911       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7912
7913       if (sect == NULL)
7914         return FALSE;
7915
7916       sect->size = note->descsz;
7917       sect->filepos = note->descpos;
7918       sect->alignment_power = 2;
7919       break;
7920
7921     default:
7922       return TRUE;
7923     }
7924
7925   return TRUE;
7926 }
7927
7928 static bfd_boolean
7929 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7930 {
7931   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7932
7933   switch (note->type)
7934     {
7935     default:
7936       return TRUE;
7937
7938     case NT_PRSTATUS:
7939       if (bed->elf_backend_grok_prstatus)
7940         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7941           return TRUE;
7942 #if defined (HAVE_PRSTATUS_T)
7943       return elfcore_grok_prstatus (abfd, note);
7944 #else
7945       return TRUE;
7946 #endif
7947
7948 #if defined (HAVE_PSTATUS_T)
7949     case NT_PSTATUS:
7950       return elfcore_grok_pstatus (abfd, note);
7951 #endif
7952
7953 #if defined (HAVE_LWPSTATUS_T)
7954     case NT_LWPSTATUS:
7955       return elfcore_grok_lwpstatus (abfd, note);
7956 #endif
7957
7958     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
7959       return elfcore_grok_prfpreg (abfd, note);
7960
7961     case NT_WIN32PSTATUS:
7962       return elfcore_grok_win32pstatus (abfd, note);
7963
7964     case NT_PRXFPREG:           /* Linux SSE extension */
7965       if (note->namesz == 6
7966           && strcmp (note->namedata, "LINUX") == 0)
7967         return elfcore_grok_prxfpreg (abfd, note);
7968       else
7969         return TRUE;
7970
7971     case NT_PPC_VMX:
7972       if (note->namesz == 6
7973           && strcmp (note->namedata, "LINUX") == 0)
7974         return elfcore_grok_ppc_vmx (abfd, note);
7975       else
7976         return TRUE;
7977
7978     case NT_PPC_VSX:
7979       if (note->namesz == 6
7980           && strcmp (note->namedata, "LINUX") == 0)
7981         return elfcore_grok_ppc_vsx (abfd, note);
7982       else
7983         return TRUE;
7984
7985     case NT_PRPSINFO:
7986     case NT_PSINFO:
7987       if (bed->elf_backend_grok_psinfo)
7988         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7989           return TRUE;
7990 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7991       return elfcore_grok_psinfo (abfd, note);
7992 #else
7993       return TRUE;
7994 #endif
7995
7996     case NT_AUXV:
7997       {
7998         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
7999                                                              SEC_HAS_CONTENTS);
8000
8001         if (sect == NULL)
8002           return FALSE;
8003         sect->size = note->descsz;
8004         sect->filepos = note->descpos;
8005         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8006
8007         return TRUE;
8008       }
8009     }
8010 }
8011
8012 static bfd_boolean
8013 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
8014 {
8015   elf_tdata (abfd)->build_id_size = note->descsz;
8016   elf_tdata (abfd)->build_id = bfd_alloc (abfd, note->descsz);
8017   if (elf_tdata (abfd)->build_id == NULL)
8018     return FALSE;
8019
8020   memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
8021
8022   return TRUE;
8023 }
8024
8025 static bfd_boolean
8026 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8027 {
8028   switch (note->type)
8029     {
8030     default:
8031       return TRUE;
8032
8033     case NT_GNU_BUILD_ID:
8034       return elfobj_grok_gnu_build_id (abfd, note);
8035     }
8036 }
8037
8038 static bfd_boolean
8039 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
8040 {
8041   char *cp;
8042
8043   cp = strchr (note->namedata, '@');
8044   if (cp != NULL)
8045     {
8046       *lwpidp = atoi(cp + 1);
8047       return TRUE;
8048     }
8049   return FALSE;
8050 }
8051
8052 static bfd_boolean
8053 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8054 {
8055   /* Signal number at offset 0x08. */
8056   elf_tdata (abfd)->core_signal
8057     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8058
8059   /* Process ID at offset 0x50. */
8060   elf_tdata (abfd)->core_pid
8061     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8062
8063   /* Command name at 0x7c (max 32 bytes, including nul). */
8064   elf_tdata (abfd)->core_command
8065     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8066
8067   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8068                                           note);
8069 }
8070
8071 static bfd_boolean
8072 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
8073 {
8074   int lwp;
8075
8076   if (elfcore_netbsd_get_lwpid (note, &lwp))
8077     elf_tdata (abfd)->core_lwpid = lwp;
8078
8079   if (note->type == NT_NETBSDCORE_PROCINFO)
8080     {
8081       /* NetBSD-specific core "procinfo".  Note that we expect to
8082          find this note before any of the others, which is fine,
8083          since the kernel writes this note out first when it
8084          creates a core file.  */
8085
8086       return elfcore_grok_netbsd_procinfo (abfd, note);
8087     }
8088
8089   /* As of Jan 2002 there are no other machine-independent notes
8090      defined for NetBSD core files.  If the note type is less
8091      than the start of the machine-dependent note types, we don't
8092      understand it.  */
8093
8094   if (note->type < NT_NETBSDCORE_FIRSTMACH)
8095     return TRUE;
8096
8097
8098   switch (bfd_get_arch (abfd))
8099     {
8100       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8101          PT_GETFPREGS == mach+2.  */
8102
8103     case bfd_arch_alpha:
8104     case bfd_arch_sparc:
8105       switch (note->type)
8106         {
8107         case NT_NETBSDCORE_FIRSTMACH+0:
8108           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8109
8110         case NT_NETBSDCORE_FIRSTMACH+2:
8111           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8112
8113         default:
8114           return TRUE;
8115         }
8116
8117       /* On all other arch's, PT_GETREGS == mach+1 and
8118          PT_GETFPREGS == mach+3.  */
8119
8120     default:
8121       switch (note->type)
8122         {
8123         case NT_NETBSDCORE_FIRSTMACH+1:
8124           return elfcore_make_note_pseudosection (abfd, ".reg", note);
8125
8126         case NT_NETBSDCORE_FIRSTMACH+3:
8127           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8128
8129         default:
8130           return TRUE;
8131         }
8132     }
8133     /* NOTREACHED */
8134 }
8135
8136 static bfd_boolean
8137 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8138 {
8139   void *ddata = note->descdata;
8140   char buf[100];
8141   char *name;
8142   asection *sect;
8143   short sig;
8144   unsigned flags;
8145
8146   /* nto_procfs_status 'pid' field is at offset 0.  */
8147   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8148
8149   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
8150   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8151
8152   /* nto_procfs_status 'flags' field is at offset 8.  */
8153   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8154
8155   /* nto_procfs_status 'what' field is at offset 14.  */
8156   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8157     {
8158       elf_tdata (abfd)->core_signal = sig;
8159       elf_tdata (abfd)->core_lwpid = *tid;
8160     }
8161
8162   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
8163      do not come from signals so we make sure we set the current
8164      thread just in case.  */
8165   if (flags & 0x00000080)
8166     elf_tdata (abfd)->core_lwpid = *tid;
8167
8168   /* Make a ".qnx_core_status/%d" section.  */
8169   sprintf (buf, ".qnx_core_status/%ld", *tid);
8170
8171   name = bfd_alloc (abfd, strlen (buf) + 1);
8172   if (name == NULL)
8173     return FALSE;
8174   strcpy (name, buf);
8175
8176   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8177   if (sect == NULL)
8178     return FALSE;
8179
8180   sect->size            = note->descsz;
8181   sect->filepos         = note->descpos;
8182   sect->alignment_power = 2;
8183
8184   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8185 }
8186
8187 static bfd_boolean
8188 elfcore_grok_nto_regs (bfd *abfd,
8189                        Elf_Internal_Note *note,
8190                        long tid,
8191                        char *base)
8192 {
8193   char buf[100];
8194   char *name;
8195   asection *sect;
8196
8197   /* Make a "(base)/%d" section.  */
8198   sprintf (buf, "%s/%ld", base, tid);
8199
8200   name = bfd_alloc (abfd, strlen (buf) + 1);
8201   if (name == NULL)
8202     return FALSE;
8203   strcpy (name, buf);
8204
8205   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8206   if (sect == NULL)
8207     return FALSE;
8208
8209   sect->size            = note->descsz;
8210   sect->filepos         = note->descpos;
8211   sect->alignment_power = 2;
8212
8213   /* This is the current thread.  */
8214   if (elf_tdata (abfd)->core_lwpid == tid)
8215     return elfcore_maybe_make_sect (abfd, base, sect);
8216
8217   return TRUE;
8218 }
8219
8220 #define BFD_QNT_CORE_INFO       7
8221 #define BFD_QNT_CORE_STATUS     8
8222 #define BFD_QNT_CORE_GREG       9
8223 #define BFD_QNT_CORE_FPREG      10
8224
8225 static bfd_boolean
8226 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8227 {
8228   /* Every GREG section has a STATUS section before it.  Store the
8229      tid from the previous call to pass down to the next gregs
8230      function.  */
8231   static long tid = 1;
8232
8233   switch (note->type)
8234     {
8235     case BFD_QNT_CORE_INFO:
8236       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8237     case BFD_QNT_CORE_STATUS:
8238       return elfcore_grok_nto_status (abfd, note, &tid);
8239     case BFD_QNT_CORE_GREG:
8240       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8241     case BFD_QNT_CORE_FPREG:
8242       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8243     default:
8244       return TRUE;
8245     }
8246 }
8247
8248 static bfd_boolean
8249 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8250 {
8251   char *name;
8252   asection *sect;
8253   size_t len;
8254
8255   /* Use note name as section name.  */
8256   len = note->namesz;
8257   name = bfd_alloc (abfd, len);
8258   if (name == NULL)
8259     return FALSE;
8260   memcpy (name, note->namedata, len);
8261   name[len - 1] = '\0';
8262
8263   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8264   if (sect == NULL)
8265     return FALSE;
8266
8267   sect->size            = note->descsz;
8268   sect->filepos         = note->descpos;
8269   sect->alignment_power = 1;
8270
8271   return TRUE;
8272 }
8273
8274 /* Function: elfcore_write_note
8275
8276    Inputs:
8277      buffer to hold note, and current size of buffer
8278      name of note
8279      type of note
8280      data for note
8281      size of data for note
8282
8283    Writes note to end of buffer.  ELF64 notes are written exactly as
8284    for ELF32, despite the current (as of 2006) ELF gabi specifying
8285    that they ought to have 8-byte namesz and descsz field, and have
8286    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
8287
8288    Return:
8289    Pointer to realloc'd buffer, *BUFSIZ updated.  */
8290
8291 char *
8292 elfcore_write_note (bfd *abfd,
8293                     char *buf,
8294                     int *bufsiz,
8295                     const char *name,
8296                     int type,
8297                     const void *input,
8298                     int size)
8299 {
8300   Elf_External_Note *xnp;
8301   size_t namesz;
8302   size_t newspace;
8303   char *dest;
8304
8305   namesz = 0;
8306   if (name != NULL)
8307     namesz = strlen (name) + 1;
8308
8309   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
8310
8311   buf = realloc (buf, *bufsiz + newspace);
8312   if (buf == NULL)
8313     return buf;
8314   dest = buf + *bufsiz;
8315   *bufsiz += newspace;
8316   xnp = (Elf_External_Note *) dest;
8317   H_PUT_32 (abfd, namesz, xnp->namesz);
8318   H_PUT_32 (abfd, size, xnp->descsz);
8319   H_PUT_32 (abfd, type, xnp->type);
8320   dest = xnp->name;
8321   if (name != NULL)
8322     {
8323       memcpy (dest, name, namesz);
8324       dest += namesz;
8325       while (namesz & 3)
8326         {
8327           *dest++ = '\0';
8328           ++namesz;
8329         }
8330     }
8331   memcpy (dest, input, size);
8332   dest += size;
8333   while (size & 3)
8334     {
8335       *dest++ = '\0';
8336       ++size;
8337     }
8338   return buf;
8339 }
8340
8341 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8342 char *
8343 elfcore_write_prpsinfo (bfd  *abfd,
8344                         char *buf,
8345                         int  *bufsiz,
8346                         const char *fname,
8347                         const char *psargs)
8348 {
8349   const char *note_name = "CORE";
8350   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8351
8352   if (bed->elf_backend_write_core_note != NULL)
8353     {
8354       char *ret;
8355       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8356                                                  NT_PRPSINFO, fname, psargs);
8357       if (ret != NULL)
8358         return ret;
8359     }
8360
8361 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8362   if (bed->s->elfclass == ELFCLASS32)
8363     {
8364 #if defined (HAVE_PSINFO32_T)
8365       psinfo32_t data;
8366       int note_type = NT_PSINFO;
8367 #else
8368       prpsinfo32_t data;
8369       int note_type = NT_PRPSINFO;
8370 #endif
8371
8372       memset (&data, 0, sizeof (data));
8373       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8374       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8375       return elfcore_write_note (abfd, buf, bufsiz,
8376                                  note_name, note_type, &data, sizeof (data));
8377     }
8378   else
8379 #endif
8380     {
8381 #if defined (HAVE_PSINFO_T)
8382       psinfo_t data;
8383       int note_type = NT_PSINFO;
8384 #else
8385       prpsinfo_t data;
8386       int note_type = NT_PRPSINFO;
8387 #endif
8388
8389       memset (&data, 0, sizeof (data));
8390       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8391       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8392       return elfcore_write_note (abfd, buf, bufsiz,
8393                                  note_name, note_type, &data, sizeof (data));
8394     }
8395 }
8396 #endif  /* PSINFO_T or PRPSINFO_T */
8397
8398 #if defined (HAVE_PRSTATUS_T)
8399 char *
8400 elfcore_write_prstatus (bfd *abfd,
8401                         char *buf,
8402                         int *bufsiz,
8403                         long pid,
8404                         int cursig,
8405                         const void *gregs)
8406 {
8407   const char *note_name = "CORE";
8408   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8409
8410   if (bed->elf_backend_write_core_note != NULL)
8411     {
8412       char *ret;
8413       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8414                                                  NT_PRSTATUS,
8415                                                  pid, cursig, gregs);
8416       if (ret != NULL)
8417         return ret;
8418     }
8419
8420 #if defined (HAVE_PRSTATUS32_T)
8421   if (bed->s->elfclass == ELFCLASS32)
8422     {
8423       prstatus32_t prstat;
8424
8425       memset (&prstat, 0, sizeof (prstat));
8426       prstat.pr_pid = pid;
8427       prstat.pr_cursig = cursig;
8428       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8429       return elfcore_write_note (abfd, buf, bufsiz, note_name,
8430                                  NT_PRSTATUS, &prstat, sizeof (prstat));
8431     }
8432   else
8433 #endif
8434     {
8435       prstatus_t prstat;
8436
8437       memset (&prstat, 0, sizeof (prstat));
8438       prstat.pr_pid = pid;
8439       prstat.pr_cursig = cursig;
8440       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8441       return elfcore_write_note (abfd, buf, bufsiz, note_name,
8442                                  NT_PRSTATUS, &prstat, sizeof (prstat));
8443     }
8444 }
8445 #endif /* HAVE_PRSTATUS_T */
8446
8447 #if defined (HAVE_LWPSTATUS_T)
8448 char *
8449 elfcore_write_lwpstatus (bfd *abfd,
8450                          char *buf,
8451                          int *bufsiz,
8452                          long pid,
8453                          int cursig,
8454                          const void *gregs)
8455 {
8456   lwpstatus_t lwpstat;
8457   const char *note_name = "CORE";
8458
8459   memset (&lwpstat, 0, sizeof (lwpstat));
8460   lwpstat.pr_lwpid  = pid >> 16;
8461   lwpstat.pr_cursig = cursig;
8462 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8463   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8464 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8465 #if !defined(gregs)
8466   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8467           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8468 #else
8469   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8470           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8471 #endif
8472 #endif
8473   return elfcore_write_note (abfd, buf, bufsiz, note_name,
8474                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8475 }
8476 #endif /* HAVE_LWPSTATUS_T */
8477
8478 #if defined (HAVE_PSTATUS_T)
8479 char *
8480 elfcore_write_pstatus (bfd *abfd,
8481                        char *buf,
8482                        int *bufsiz,
8483                        long pid,
8484                        int cursig ATTRIBUTE_UNUSED,
8485                        const void *gregs ATTRIBUTE_UNUSED)
8486 {
8487   const char *note_name = "CORE";
8488 #if defined (HAVE_PSTATUS32_T)
8489   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8490
8491   if (bed->s->elfclass == ELFCLASS32)
8492     {
8493       pstatus32_t pstat;
8494
8495       memset (&pstat, 0, sizeof (pstat));
8496       pstat.pr_pid = pid & 0xffff;
8497       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8498                                 NT_PSTATUS, &pstat, sizeof (pstat));
8499       return buf;
8500     }
8501   else
8502 #endif
8503     {
8504       pstatus_t pstat;
8505
8506       memset (&pstat, 0, sizeof (pstat));
8507       pstat.pr_pid = pid & 0xffff;
8508       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8509                                 NT_PSTATUS, &pstat, sizeof (pstat));
8510       return buf;
8511     }
8512 }
8513 #endif /* HAVE_PSTATUS_T */
8514
8515 char *
8516 elfcore_write_prfpreg (bfd *abfd,
8517                        char *buf,
8518                        int *bufsiz,
8519                        const void *fpregs,
8520                        int size)
8521 {
8522   const char *note_name = "CORE";
8523   return elfcore_write_note (abfd, buf, bufsiz,
8524                              note_name, NT_FPREGSET, fpregs, size);
8525 }
8526
8527 char *
8528 elfcore_write_prxfpreg (bfd *abfd,
8529                         char *buf,
8530                         int *bufsiz,
8531                         const void *xfpregs,
8532                         int size)
8533 {
8534   char *note_name = "LINUX";
8535   return elfcore_write_note (abfd, buf, bufsiz,
8536                              note_name, NT_PRXFPREG, xfpregs, size);
8537 }
8538
8539 char *
8540 elfcore_write_ppc_vmx (bfd *abfd,
8541                        char *buf,
8542                        int *bufsiz,
8543                        const void *ppc_vmx,
8544                        int size)
8545 {
8546   char *note_name = "LINUX";
8547   return elfcore_write_note (abfd, buf, bufsiz,
8548                              note_name, NT_PPC_VMX, ppc_vmx, size);
8549 }
8550
8551 char *
8552 elfcore_write_ppc_vsx (bfd *abfd,
8553                        char *buf,
8554                        int *bufsiz,
8555                        const void *ppc_vsx,
8556                        int size)
8557 {
8558   char *note_name = "LINUX";
8559   return elfcore_write_note (abfd, buf, bufsiz,
8560                              note_name, NT_PPC_VSX, ppc_vsx, size);
8561 }
8562
8563 char *
8564 elfcore_write_register_note (bfd *abfd,
8565                              char *buf,
8566                              int *bufsiz,
8567                              const char *section,
8568                              const void *data,
8569                              int size)
8570 {
8571   if (strcmp (section, ".reg2") == 0)
8572     return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
8573   if (strcmp (section, ".reg-xfp") == 0)
8574     return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
8575   if (strcmp (section, ".reg-ppc-vmx") == 0)
8576     return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
8577   if (strcmp (section, ".reg-ppc-vsx") == 0)
8578     return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
8579   return NULL;
8580 }
8581
8582 static bfd_boolean
8583 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
8584 {
8585   char *p;
8586
8587   p = buf;
8588   while (p < buf + size)
8589     {
8590       /* FIXME: bad alignment assumption.  */
8591       Elf_External_Note *xnp = (Elf_External_Note *) p;
8592       Elf_Internal_Note in;
8593
8594       if (offsetof (Elf_External_Note, name) > buf - p + size)
8595         return FALSE;
8596
8597       in.type = H_GET_32 (abfd, xnp->type);
8598
8599       in.namesz = H_GET_32 (abfd, xnp->namesz);
8600       in.namedata = xnp->name;
8601       if (in.namesz > buf - in.namedata + size)
8602         return FALSE;
8603
8604       in.descsz = H_GET_32 (abfd, xnp->descsz);
8605       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8606       in.descpos = offset + (in.descdata - buf);
8607       if (in.descsz != 0
8608           && (in.descdata >= buf + size
8609               || in.descsz > buf - in.descdata + size))
8610         return FALSE;
8611
8612       switch (bfd_get_format (abfd))
8613         {
8614         default:
8615           return TRUE;
8616
8617         case bfd_core:
8618           if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
8619             {
8620               if (! elfcore_grok_netbsd_note (abfd, &in))
8621                 return FALSE;
8622             }
8623           else if (CONST_STRNEQ (in.namedata, "QNX"))
8624             {
8625               if (! elfcore_grok_nto_note (abfd, &in))
8626                 return FALSE;
8627             }
8628           else if (CONST_STRNEQ (in.namedata, "SPU/"))
8629             {
8630               if (! elfcore_grok_spu_note (abfd, &in))
8631                 return FALSE;
8632             }
8633           else
8634             {
8635               if (! elfcore_grok_note (abfd, &in))
8636                 return FALSE;
8637             }
8638           break;
8639
8640         case bfd_object:
8641           if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
8642             {
8643               if (! elfobj_grok_gnu_note (abfd, &in))
8644                 return FALSE;
8645             }
8646           break;
8647         }
8648
8649       p = in.descdata + BFD_ALIGN (in.descsz, 4);
8650     }
8651
8652   return TRUE;
8653 }
8654
8655 static bfd_boolean
8656 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
8657 {
8658   char *buf;
8659
8660   if (size <= 0)
8661     return TRUE;
8662
8663   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
8664     return FALSE;
8665
8666   buf = bfd_malloc (size);
8667   if (buf == NULL)
8668     return FALSE;
8669
8670   if (bfd_bread (buf, size, abfd) != size
8671       || !elf_parse_notes (abfd, buf, size, offset))
8672     {
8673       free (buf);
8674       return FALSE;
8675     }
8676
8677   free (buf);
8678   return TRUE;
8679 }
8680 \f
8681 /* Providing external access to the ELF program header table.  */
8682
8683 /* Return an upper bound on the number of bytes required to store a
8684    copy of ABFD's program header table entries.  Return -1 if an error
8685    occurs; bfd_get_error will return an appropriate code.  */
8686
8687 long
8688 bfd_get_elf_phdr_upper_bound (bfd *abfd)
8689 {
8690   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8691     {
8692       bfd_set_error (bfd_error_wrong_format);
8693       return -1;
8694     }
8695
8696   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
8697 }
8698
8699 /* Copy ABFD's program header table entries to *PHDRS.  The entries
8700    will be stored as an array of Elf_Internal_Phdr structures, as
8701    defined in include/elf/internal.h.  To find out how large the
8702    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8703
8704    Return the number of program header table entries read, or -1 if an
8705    error occurs; bfd_get_error will return an appropriate code.  */
8706
8707 int
8708 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
8709 {
8710   int num_phdrs;
8711
8712   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8713     {
8714       bfd_set_error (bfd_error_wrong_format);
8715       return -1;
8716     }
8717
8718   num_phdrs = elf_elfheader (abfd)->e_phnum;
8719   memcpy (phdrs, elf_tdata (abfd)->phdr,
8720           num_phdrs * sizeof (Elf_Internal_Phdr));
8721
8722   return num_phdrs;
8723 }
8724
8725 enum elf_reloc_type_class
8726 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8727 {
8728   return reloc_class_normal;
8729 }
8730
8731 /* For RELA architectures, return the relocation value for a
8732    relocation against a local symbol.  */
8733
8734 bfd_vma
8735 _bfd_elf_rela_local_sym (bfd *abfd,
8736                          Elf_Internal_Sym *sym,
8737                          asection **psec,
8738                          Elf_Internal_Rela *rel)
8739 {
8740   asection *sec = *psec;
8741   bfd_vma relocation;
8742
8743   relocation = (sec->output_section->vma
8744                 + sec->output_offset
8745                 + sym->st_value);
8746   if ((sec->flags & SEC_MERGE)
8747       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8748       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8749     {
8750       rel->r_addend =
8751         _bfd_merged_section_offset (abfd, psec,
8752                                     elf_section_data (sec)->sec_info,
8753                                     sym->st_value + rel->r_addend);
8754       if (sec != *psec)
8755         {
8756           /* If we have changed the section, and our original section is
8757              marked with SEC_EXCLUDE, it means that the original
8758              SEC_MERGE section has been completely subsumed in some
8759              other SEC_MERGE section.  In this case, we need to leave
8760              some info around for --emit-relocs.  */
8761           if ((sec->flags & SEC_EXCLUDE) != 0)
8762             sec->kept_section = *psec;
8763           sec = *psec;
8764         }
8765       rel->r_addend -= relocation;
8766       rel->r_addend += sec->output_section->vma + sec->output_offset;
8767     }
8768   return relocation;
8769 }
8770
8771 bfd_vma
8772 _bfd_elf_rel_local_sym (bfd *abfd,
8773                         Elf_Internal_Sym *sym,
8774                         asection **psec,
8775                         bfd_vma addend)
8776 {
8777   asection *sec = *psec;
8778
8779   if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8780     return sym->st_value + addend;
8781
8782   return _bfd_merged_section_offset (abfd, psec,
8783                                      elf_section_data (sec)->sec_info,
8784                                      sym->st_value + addend);
8785 }
8786
8787 bfd_vma
8788 _bfd_elf_section_offset (bfd *abfd,
8789                          struct bfd_link_info *info,
8790                          asection *sec,
8791                          bfd_vma offset)
8792 {
8793   switch (sec->sec_info_type)
8794     {
8795     case ELF_INFO_TYPE_STABS:
8796       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8797                                        offset);
8798     case ELF_INFO_TYPE_EH_FRAME:
8799       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8800     default:
8801       return offset;
8802     }
8803 }
8804 \f
8805 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
8806    reconstruct an ELF file by reading the segments out of remote memory
8807    based on the ELF file header at EHDR_VMA and the ELF program headers it
8808    points to.  If not null, *LOADBASEP is filled in with the difference
8809    between the VMAs from which the segments were read, and the VMAs the
8810    file headers (and hence BFD's idea of each section's VMA) put them at.
8811
8812    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8813    remote memory at target address VMA into the local buffer at MYADDR; it
8814    should return zero on success or an `errno' code on failure.  TEMPL must
8815    be a BFD for an ELF target with the word size and byte order found in
8816    the remote memory.  */
8817
8818 bfd *
8819 bfd_elf_bfd_from_remote_memory
8820   (bfd *templ,
8821    bfd_vma ehdr_vma,
8822    bfd_vma *loadbasep,
8823    int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8824 {
8825   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8826     (templ, ehdr_vma, loadbasep, target_read_memory);
8827 }
8828 \f
8829 long
8830 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8831                                long symcount ATTRIBUTE_UNUSED,
8832                                asymbol **syms ATTRIBUTE_UNUSED,
8833                                long dynsymcount,
8834                                asymbol **dynsyms,
8835                                asymbol **ret)
8836 {
8837   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8838   asection *relplt;
8839   asymbol *s;
8840   const char *relplt_name;
8841   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8842   arelent *p;
8843   long count, i, n;
8844   size_t size;
8845   Elf_Internal_Shdr *hdr;
8846   char *names;
8847   asection *plt;
8848
8849   *ret = NULL;
8850
8851   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8852     return 0;
8853
8854   if (dynsymcount <= 0)
8855     return 0;
8856
8857   if (!bed->plt_sym_val)
8858     return 0;
8859
8860   relplt_name = bed->relplt_name;
8861   if (relplt_name == NULL)
8862     relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
8863   relplt = bfd_get_section_by_name (abfd, relplt_name);
8864   if (relplt == NULL)
8865     return 0;
8866
8867   hdr = &elf_section_data (relplt)->this_hdr;
8868   if (hdr->sh_link != elf_dynsymtab (abfd)
8869       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8870     return 0;
8871
8872   plt = bfd_get_section_by_name (abfd, ".plt");
8873   if (plt == NULL)
8874     return 0;
8875
8876   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8877   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8878     return -1;
8879
8880   count = relplt->size / hdr->sh_entsize;
8881   size = count * sizeof (asymbol);
8882   p = relplt->relocation;
8883   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
8884     size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8885
8886   s = *ret = bfd_malloc (size);
8887   if (s == NULL)
8888     return -1;
8889
8890   names = (char *) (s + count);
8891   p = relplt->relocation;
8892   n = 0;
8893   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
8894     {
8895       size_t len;
8896       bfd_vma addr;
8897
8898       addr = bed->plt_sym_val (i, plt, p);
8899       if (addr == (bfd_vma) -1)
8900         continue;
8901
8902       *s = **p->sym_ptr_ptr;
8903       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
8904          we are defining a symbol, ensure one of them is set.  */
8905       if ((s->flags & BSF_LOCAL) == 0)
8906         s->flags |= BSF_GLOBAL;
8907       s->flags |= BSF_SYNTHETIC;
8908       s->section = plt;
8909       s->value = addr - plt->vma;
8910       s->name = names;
8911       s->udata.p = NULL;
8912       len = strlen ((*p->sym_ptr_ptr)->name);
8913       memcpy (names, (*p->sym_ptr_ptr)->name, len);
8914       names += len;
8915       memcpy (names, "@plt", sizeof ("@plt"));
8916       names += sizeof ("@plt");
8917       ++s, ++n;
8918     }
8919
8920   return n;
8921 }
8922
8923 /* It is only used by x86-64 so far.  */
8924 asection _bfd_elf_large_com_section
8925   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
8926                       SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
8927
8928 void
8929 _bfd_elf_set_osabi (bfd * abfd,
8930                     struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
8931 {
8932   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
8933
8934   i_ehdrp = elf_elfheader (abfd);
8935
8936   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
8937 }
8938
8939
8940 /* Return TRUE for ELF symbol types that represent functions.
8941    This is the default version of this function, which is sufficient for
8942    most targets.  It returns true if TYPE is STT_FUNC.  */
8943
8944 bfd_boolean
8945 _bfd_elf_is_function_type (unsigned int type)
8946 {
8947   return (type == STT_FUNC);
8948 }