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