bfd/elf.c

   1 /* ELF executable support for BFD.
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /*  SECTION
  22
  23         ELF backends
  24
  25         BFD support for ELF formats is being worked on.
  26         Currently, the best supported back ends are for sparc and i386
  27         (running svr4 or Solaris 2).
  28
  29         Documentation of the internals of the support code still needs
  30         to be written.  The code is changing quickly enough that we
  31         haven't bothered yet.  */
  32
  33 /* For sparc64-cross-sparc32.  */
  34 #define _SYSCALL32
  35 #include "bfd.h"
  36 #include "sysdep.h"
  37 #include "bfdlink.h"
  38 #include "libbfd.h"
  39 #define ARCH_SIZE 0
  40 #include "elf-bfd.h"
  41 #include "libiberty.h"
  42
  43 static INLINE struct elf_segment_map *make_mapping
  44   PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
  45 static boolean map_sections_to_segments PARAMS ((bfd *));
  46 static int elf_sort_sections PARAMS ((const PTR, const PTR));
  47 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
  48 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
  49 static boolean prep_headers PARAMS ((bfd *));
  50 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
  51 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
  52 static char *elf_read PARAMS ((bfd *, file_ptr, bfd_size_type));
  53 static const char *group_signature PARAMS ((bfd *, Elf_Internal_Shdr *));
  54 static boolean setup_group PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
  55 static void merge_sections_remove_hook PARAMS ((bfd *, asection *));
  56 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
  57 static boolean assign_section_numbers PARAMS ((bfd *));
  58 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
  59 static boolean elf_map_symbols PARAMS ((bfd *));
  60 static bfd_size_type get_program_header_size PARAMS ((bfd *));
  61 static boolean elfcore_read_notes PARAMS ((bfd *, file_ptr, bfd_size_type));
  62 static boolean elf_find_function PARAMS ((bfd *, asection *, asymbol **,
  63                                           bfd_vma, const char **,
  64                                           const char **));
  65 static int elfcore_make_pid PARAMS ((bfd *));
  66 static boolean elfcore_maybe_make_sect PARAMS ((bfd *, char *, asection *));
  67 static boolean elfcore_make_note_pseudosection PARAMS ((bfd *, char *,
  68                                                         Elf_Internal_Note *));
  69 static boolean elfcore_grok_prfpreg PARAMS ((bfd *, Elf_Internal_Note *));
  70 static boolean elfcore_grok_prxfpreg PARAMS ((bfd *, Elf_Internal_Note *));
  71 static boolean elfcore_grok_note PARAMS ((bfd *, Elf_Internal_Note *));
  72
  73 static boolean elfcore_netbsd_get_lwpid PARAMS ((Elf_Internal_Note *, int *));
  74 static boolean elfcore_grok_netbsd_procinfo PARAMS ((bfd *,
  75                                                      Elf_Internal_Note *));
  76 static boolean elfcore_grok_netbsd_note PARAMS ((bfd *, Elf_Internal_Note *));
  77
  78 /* Swap version information in and out.  The version information is
  79    currently size independent.  If that ever changes, this code will
  80    need to move into elfcode.h.  */
  81
  82 /* Swap in a Verdef structure.  */
  83
  84 void
  85 _bfd_elf_swap_verdef_in (abfd, src, dst)
  86      bfd *abfd;
  87      const Elf_External_Verdef *src;
  88      Elf_Internal_Verdef *dst;
  89 {
  90   dst->vd_version = H_GET_16 (abfd, src->vd_version);
  91   dst->vd_flags   = H_GET_16 (abfd, src->vd_flags);
  92   dst->vd_ndx     = H_GET_16 (abfd, src->vd_ndx);
  93   dst->vd_cnt     = H_GET_16 (abfd, src->vd_cnt);
  94   dst->vd_hash    = H_GET_32 (abfd, src->vd_hash);
  95   dst->vd_aux     = H_GET_32 (abfd, src->vd_aux);
  96   dst->vd_next    = H_GET_32 (abfd, src->vd_next);
  97 }
  98
  99 /* Swap out a Verdef structure.  */
 100
 101 void
 102 _bfd_elf_swap_verdef_out (abfd, src, dst)
 103      bfd *abfd;
 104      const Elf_Internal_Verdef *src;
 105      Elf_External_Verdef *dst;
 106 {
 107   H_PUT_16 (abfd, src->vd_version, dst->vd_version);
 108   H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
 109   H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
 110   H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
 111   H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
 112   H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
 113   H_PUT_32 (abfd, src->vd_next, dst->vd_next);
 114 }
 115
 116 /* Swap in a Verdaux structure.  */
 117
 118 void
 119 _bfd_elf_swap_verdaux_in (abfd, src, dst)
 120      bfd *abfd;
 121      const Elf_External_Verdaux *src;
 122      Elf_Internal_Verdaux *dst;
 123 {
 124   dst->vda_name = H_GET_32 (abfd, src->vda_name);
 125   dst->vda_next = H_GET_32 (abfd, src->vda_next);
 126 }
 127
 128 /* Swap out a Verdaux structure.  */
 129
 130 void
 131 _bfd_elf_swap_verdaux_out (abfd, src, dst)
 132      bfd *abfd;
 133      const Elf_Internal_Verdaux *src;
 134      Elf_External_Verdaux *dst;
 135 {
 136   H_PUT_32 (abfd, src->vda_name, dst->vda_name);
 137   H_PUT_32 (abfd, src->vda_next, dst->vda_next);
 138 }
 139
 140 /* Swap in a Verneed structure.  */
 141
 142 void
 143 _bfd_elf_swap_verneed_in (abfd, src, dst)
 144      bfd *abfd;
 145      const Elf_External_Verneed *src;
 146      Elf_Internal_Verneed *dst;
 147 {
 148   dst->vn_version = H_GET_16 (abfd, src->vn_version);
 149   dst->vn_cnt     = H_GET_16 (abfd, src->vn_cnt);
 150   dst->vn_file    = H_GET_32 (abfd, src->vn_file);
 151   dst->vn_aux     = H_GET_32 (abfd, src->vn_aux);
 152   dst->vn_next    = H_GET_32 (abfd, src->vn_next);
 153 }
 154
 155 /* Swap out a Verneed structure.  */
 156
 157 void
 158 _bfd_elf_swap_verneed_out (abfd, src, dst)
 159      bfd *abfd;
 160      const Elf_Internal_Verneed *src;
 161      Elf_External_Verneed *dst;
 162 {
 163   H_PUT_16 (abfd, src->vn_version, dst->vn_version);
 164   H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
 165   H_PUT_32 (abfd, src->vn_file, dst->vn_file);
 166   H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
 167   H_PUT_32 (abfd, src->vn_next, dst->vn_next);
 168 }
 169
 170 /* Swap in a Vernaux structure.  */
 171
 172 void
 173 _bfd_elf_swap_vernaux_in (abfd, src, dst)
 174      bfd *abfd;
 175      const Elf_External_Vernaux *src;
 176      Elf_Internal_Vernaux *dst;
 177 {
 178   dst->vna_hash  = H_GET_32 (abfd, src->vna_hash);
 179   dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
 180   dst->vna_other = H_GET_16 (abfd, src->vna_other);
 181   dst->vna_name  = H_GET_32 (abfd, src->vna_name);
 182   dst->vna_next  = H_GET_32 (abfd, src->vna_next);
 183 }
 184
 185 /* Swap out a Vernaux structure.  */
 186
 187 void
 188 _bfd_elf_swap_vernaux_out (abfd, src, dst)
 189      bfd *abfd;
 190      const Elf_Internal_Vernaux *src;
 191      Elf_External_Vernaux *dst;
 192 {
 193   H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
 194   H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
 195   H_PUT_16 (abfd, src->vna_other, dst->vna_other);
 196   H_PUT_32 (abfd, src->vna_name, dst->vna_name);
 197   H_PUT_32 (abfd, src->vna_next, dst->vna_next);
 198 }
 199
 200 /* Swap in a Versym structure.  */
 201
 202 void
 203 _bfd_elf_swap_versym_in (abfd, src, dst)
 204      bfd *abfd;
 205      const Elf_External_Versym *src;
 206      Elf_Internal_Versym *dst;
 207 {
 208   dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
 209 }
 210
 211 /* Swap out a Versym structure.  */
 212
 213 void
 214 _bfd_elf_swap_versym_out (abfd, src, dst)
 215      bfd *abfd;
 216      const Elf_Internal_Versym *src;
 217      Elf_External_Versym *dst;
 218 {
 219   H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
 220 }
 221
 222 /* Standard ELF hash function.  Do not change this function; you will
 223    cause invalid hash tables to be generated.  */
 224
 225 unsigned long
 226 bfd_elf_hash (namearg)
 227      const char *namearg;
 228 {
 229   const unsigned char *name = (const unsigned char *) namearg;
 230   unsigned long h = 0;
 231   unsigned long g;
 232   int ch;
 233
 234   while ((ch = *name++) != '\0')
 235     {
 236       h = (h << 4) + ch;
 237       if ((g = (h & 0xf0000000)) != 0)
 238         {
 239           h ^= g >> 24;
 240           /* The ELF ABI says `h &= ~g', but this is equivalent in
 241              this case and on some machines one insn instead of two.  */
 242           h ^= g;
 243         }
 244     }
 245   return h;
 246 }
 247
 248 /* Read a specified number of bytes at a specified offset in an ELF
 249    file, into a newly allocated buffer, and return a pointer to the
 250    buffer.  */
 251
 252 static char *
 253 elf_read (abfd, offset, size)
 254      bfd *abfd;
 255      file_ptr offset;
 256      bfd_size_type size;
 257 {
 258   char *buf;
 259
 260   if ((buf = bfd_alloc (abfd, size)) == NULL)
 261     return NULL;
 262   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
 263     return NULL;
 264   if (bfd_bread ((PTR) buf, size, abfd) != size)
 265     {
 266       if (bfd_get_error () != bfd_error_system_call)
 267         bfd_set_error (bfd_error_file_truncated);
 268       return NULL;
 269     }
 270   return buf;
 271 }
 272
 273 boolean
 274 bfd_elf_mkobject (abfd)
 275      bfd *abfd;
 276 {
 277   /* This just does initialization.  */
 278   /* coff_mkobject zalloc's space for tdata.coff_obj_data ...  */
 279   bfd_size_type amt = sizeof (struct elf_obj_tdata);
 280   elf_tdata (abfd) = (struct elf_obj_tdata *) bfd_zalloc (abfd, amt);
 281   if (elf_tdata (abfd) == 0)
 282     return false;
 283   /* Since everything is done at close time, do we need any
 284      initialization?  */
 285
 286   return true;
 287 }
 288
 289 boolean
 290 bfd_elf_mkcorefile (abfd)
 291      bfd *abfd;
 292 {
 293   /* I think this can be done just like an object file.  */
 294   return bfd_elf_mkobject (abfd);
 295 }
 296
 297 char *
 298 bfd_elf_get_str_section (abfd, shindex)
 299      bfd *abfd;
 300      unsigned int shindex;
 301 {
 302   Elf_Internal_Shdr **i_shdrp;
 303   char *shstrtab = NULL;
 304   file_ptr offset;
 305   bfd_size_type shstrtabsize;
 306
 307   i_shdrp = elf_elfsections (abfd);
 308   if (i_shdrp == 0 || i_shdrp[shindex] == 0)
 309     return 0;
 310
 311   shstrtab = (char *) i_shdrp[shindex]->contents;
 312   if (shstrtab == NULL)
 313     {
 314       /* No cached one, attempt to read, and cache what we read.  */
 315       offset = i_shdrp[shindex]->sh_offset;
 316       shstrtabsize = i_shdrp[shindex]->sh_size;
 317       shstrtab = elf_read (abfd, offset, shstrtabsize);
 318       i_shdrp[shindex]->contents = (PTR) shstrtab;
 319     }
 320   return shstrtab;
 321 }
 322
 323 char *
 324 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
 325      bfd *abfd;
 326      unsigned int shindex;
 327      unsigned int strindex;
 328 {
 329   Elf_Internal_Shdr *hdr;
 330
 331   if (strindex == 0)
 332     return "";
 333
 334   hdr = elf_elfsections (abfd)[shindex];
 335
 336   if (hdr->contents == NULL
 337       && bfd_elf_get_str_section (abfd, shindex) == NULL)
 338     return NULL;
 339
 340   if (strindex >= hdr->sh_size)
 341     {
 342       (*_bfd_error_handler)
 343         (_("%s: invalid string offset %u >= %lu for section `%s'"),
 344          bfd_archive_filename (abfd), strindex, (unsigned long) hdr->sh_size,
 345          ((shindex == elf_elfheader(abfd)->e_shstrndx
 346            && strindex == hdr->sh_name)
 347           ? ".shstrtab"
 348           : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
 349       return "";
 350     }
 351
 352   return ((char *) hdr->contents) + strindex;
 353 }
 354
 355 /* Read and convert symbols to internal format.
 356    SYMCOUNT specifies the number of symbols to read, starting from
 357    symbol SYMOFFSET.  If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
 358    are non-NULL, they are used to store the internal symbols, external
 359    symbols, and symbol section index extensions, respectively.  */
 360
 361 Elf_Internal_Sym *
 362 bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, symoffset,
 363                       intsym_buf, extsym_buf, extshndx_buf)
 364      bfd *ibfd;
 365      Elf_Internal_Shdr *symtab_hdr;
 366      size_t symcount;
 367      size_t symoffset;
 368      Elf_Internal_Sym *intsym_buf;
 369      PTR extsym_buf;
 370      Elf_External_Sym_Shndx *extshndx_buf;
 371 {
 372   Elf_Internal_Shdr *shndx_hdr;
 373   PTR alloc_ext;
 374   const bfd_byte *esym;
 375   Elf_External_Sym_Shndx *alloc_extshndx;
 376   Elf_External_Sym_Shndx *shndx;
 377   Elf_Internal_Sym *isym;
 378   Elf_Internal_Sym *isymend;
 379   struct elf_backend_data *bed;
 380   size_t extsym_size;
 381   bfd_size_type amt;
 382   file_ptr pos;
 383
 384   if (symcount == 0)
 385     return intsym_buf;
 386
 387   /* Normal syms might have section extension entries.  */
 388   shndx_hdr = NULL;
 389   if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
 390     shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
 391
 392   /* Read the symbols.  */
 393   alloc_ext = NULL;
 394   alloc_extshndx = NULL;
 395   bed = get_elf_backend_data (ibfd);
 396   extsym_size = bed->s->sizeof_sym;
 397   amt = symcount * extsym_size;
 398   pos = symtab_hdr->sh_offset + symoffset * extsym_size;
 399   if (extsym_buf == NULL)
 400     {
 401       alloc_ext = bfd_malloc (amt);
 402       extsym_buf = alloc_ext;
 403     }
 404   if (extsym_buf == NULL
 405       || bfd_seek (ibfd, pos, SEEK_SET) != 0
 406       || bfd_bread (extsym_buf, amt, ibfd) != amt)
 407     {
 408       intsym_buf = NULL;
 409       goto out;
 410     }
 411
 412   if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
 413     extshndx_buf = NULL;
 414   else
 415     {
 416       amt = symcount * sizeof (Elf_External_Sym_Shndx);
 417       pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
 418       if (extshndx_buf == NULL)
 419         {
 420           alloc_extshndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
 421           extshndx_buf = alloc_extshndx;
 422         }
 423       if (extshndx_buf == NULL
 424           || bfd_seek (ibfd, pos, SEEK_SET) != 0
 425           || bfd_bread (extshndx_buf, amt, ibfd) != amt)
 426         {
 427           intsym_buf = NULL;
 428           goto out;
 429         }
 430     }
 431
 432   if (intsym_buf == NULL)
 433     {
 434       bfd_size_type amt = symcount * sizeof (Elf_Internal_Sym);
 435       intsym_buf = (Elf_Internal_Sym *) bfd_malloc (amt);
 436       if (intsym_buf == NULL)
 437         goto out;
 438     }
 439
 440   /* Convert the symbols to internal form.  */
 441   isymend = intsym_buf + symcount;
 442   for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
 443        isym < isymend;
 444        esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
 445     (*bed->s->swap_symbol_in) (ibfd, esym, (const PTR) shndx, isym);
 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 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
 457    sections.  The first element is the flags, the rest are section
 458    pointers.  */
 459
 460 typedef union elf_internal_group {
 461   Elf_Internal_Shdr *shdr;
 462   unsigned int flags;
 463 } Elf_Internal_Group;
 464
 465 /* Return the name of the group signature symbol.  Why isn't the
 466    signature just a string?  */
 467
 468 static const char *
 469 group_signature (abfd, ghdr)
 470      bfd *abfd;
 471      Elf_Internal_Shdr *ghdr;
 472 {
 473   Elf_Internal_Shdr *hdr;
 474   unsigned char esym[sizeof (Elf64_External_Sym)];
 475   Elf_External_Sym_Shndx eshndx;
 476   Elf_Internal_Sym isym;
 477   unsigned int iname;
 478   unsigned int shindex;
 479
 480   /* First we need to ensure the symbol table is available.  */
 481   if (! bfd_section_from_shdr (abfd, ghdr->sh_link))
 482     return NULL;
 483
 484   /* Go read the symbol.  */
 485   hdr = &elf_tdata (abfd)->symtab_hdr;
 486   if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
 487                             &isym, esym, &eshndx) == NULL)
 488     return NULL;
 489
 490   /* Look up the symbol name.  */
 491   iname = isym.st_name;
 492   shindex = hdr->sh_link;
 493   if (iname == 0 && ELF_ST_TYPE (isym.st_info) == STT_SECTION)
 494     {
 495       iname = elf_elfsections (abfd)[isym.st_shndx]->sh_name;
 496       shindex = elf_elfheader (abfd)->e_shstrndx;
 497     }
 498
 499   return bfd_elf_string_from_elf_section (abfd, shindex, iname);
 500 }
 501
 502 /* Set next_in_group list pointer, and group name for NEWSECT.  */
 503
 504 static boolean
 505 setup_group (abfd, hdr, newsect)
 506      bfd *abfd;
 507      Elf_Internal_Shdr *hdr;
 508      asection *newsect;
 509 {
 510   unsigned int num_group = elf_tdata (abfd)->num_group;
 511
 512   /* If num_group is zero, read in all SHT_GROUP sections.  The count
 513      is set to -1 if there are no SHT_GROUP sections.  */
 514   if (num_group == 0)
 515     {
 516       unsigned int i, shnum;
 517
 518       /* First count the number of groups.  If we have a SHT_GROUP
 519          section with just a flag word (ie. sh_size is 4), ignore it.  */
 520       shnum = elf_numsections (abfd);
 521       num_group = 0;
 522       for (i = 0; i < shnum; i++)
 523         {
 524           Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
 525           if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
 526             num_group += 1;
 527         }
 528
 529       if (num_group == 0)
 530         num_group = (unsigned) -1;
 531       elf_tdata (abfd)->num_group = num_group;
 532
 533       if (num_group > 0)
 534         {
 535           /* We keep a list of elf section headers for group sections,
 536              so we can find them quickly.  */
 537           bfd_size_type amt = num_group * sizeof (Elf_Internal_Shdr *);
 538           elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
 539           if (elf_tdata (abfd)->group_sect_ptr == NULL)
 540             return false;
 541
 542           num_group = 0;
 543           for (i = 0; i < shnum; i++)
 544             {
 545               Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
 546               if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
 547                 {
 548                   unsigned char *src;
 549                   Elf_Internal_Group *dest;
 550
 551                   /* Add to list of sections.  */
 552                   elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
 553                   num_group += 1;
 554
 555                   /* Read the raw contents.  */
 556                   BFD_ASSERT (sizeof (*dest) >= 4);
 557                   amt = shdr->sh_size * sizeof (*dest) / 4;
 558                   shdr->contents = bfd_alloc (abfd, amt);
 559                   if (shdr->contents == NULL
 560                       || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
 561                       || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
 562                           != shdr->sh_size))
 563                     return false;
 564
 565                   /* Translate raw contents, a flag word followed by an
 566                      array of elf section indices all in target byte order,
 567                      to the flag word followed by an array of elf section
 568                      pointers.  */
 569                   src = shdr->contents + shdr->sh_size;
 570                   dest = (Elf_Internal_Group *) (shdr->contents + amt);
 571                   while (1)
 572                     {
 573                       unsigned int idx;
 574
 575                       src -= 4;
 576                       --dest;
 577                       idx = H_GET_32 (abfd, src);
 578                       if (src == shdr->contents)
 579                         {
 580                           dest->flags = idx;
 581                           if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
 582                             shdr->bfd_section->flags
 583                               |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 584                           break;
 585                         }
 586                       if (idx >= shnum)
 587                         {
 588                           ((*_bfd_error_handler)
 589                            (_("%s: invalid SHT_GROUP entry"),
 590                             bfd_archive_filename (abfd)));
 591                           idx = 0;
 592                         }
 593                       dest->shdr = elf_elfsections (abfd)[idx];
 594                     }
 595                 }
 596             }
 597         }
 598     }
 599
 600   if (num_group != (unsigned) -1)
 601     {
 602       unsigned int i;
 603
 604       for (i = 0; i < num_group; i++)
 605         {
 606           Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
 607           Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
 608           unsigned int n_elt = shdr->sh_size / 4;
 609
 610           /* Look through this group's sections to see if current
 611              section is a member.  */
 612           while (--n_elt != 0)
 613             if ((++idx)->shdr == hdr)
 614               {
 615                 asection *s = NULL;
 616
 617                 /* We are a member of this group.  Go looking through
 618                    other members to see if any others are linked via
 619                    next_in_group.  */
 620                 idx = (Elf_Internal_Group *) shdr->contents;
 621                 n_elt = shdr->sh_size / 4;
 622                 while (--n_elt != 0)
 623                   if ((s = (++idx)->shdr->bfd_section) != NULL
 624                       && elf_next_in_group (s) != NULL)
 625                     break;
 626                 if (n_elt != 0)
 627                   {
 628                     /* Snarf the group name from other member, and
 629                        insert current section in circular list.  */
 630                     elf_group_name (newsect) = elf_group_name (s);
 631                     elf_next_in_group (newsect) = elf_next_in_group (s);
 632                     elf_next_in_group (s) = newsect;
 633                   }
 634                 else
 635                   {
 636                     const char *gname;
 637
 638                     gname = group_signature (abfd, shdr);
 639                     if (gname == NULL)
 640                       return false;
 641                     elf_group_name (newsect) = gname;
 642
 643                     /* Start a circular list with one element.  */
 644                     elf_next_in_group (newsect) = newsect;
 645                   }
 646
 647                 /* If the group section has been created, point to the
 648                    new member.  */
 649                 if (shdr->bfd_section != NULL)
 650                   elf_next_in_group (shdr->bfd_section) = newsect;
 651
 652                 i = num_group - 1;
 653                 break;
 654               }
 655         }
 656     }
 657
 658   if (elf_group_name (newsect) == NULL)
 659     {
 660       (*_bfd_error_handler) (_("%s: no group info for section %s"),
 661                              bfd_archive_filename (abfd), newsect->name);
 662     }
 663   return true;
 664 }
 665
 666 boolean
 667 bfd_elf_discard_group (abfd, group)
 668      bfd *abfd ATTRIBUTE_UNUSED;
 669      asection *group;
 670 {
 671   asection *first = elf_next_in_group (group);
 672   asection *s = first;
 673
 674   while (s != NULL)
 675     {
 676       s->output_section = bfd_abs_section_ptr;
 677       s = elf_next_in_group (s);
 678       /* These lists are circular.  */
 679       if (s == first)
 680         break;
 681     }
 682   return true;
 683 }
 684
 685 /* Make a BFD section from an ELF section.  We store a pointer to the
 686    BFD section in the bfd_section field of the header.  */
 687
 688 boolean
 689 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
 690      bfd *abfd;
 691      Elf_Internal_Shdr *hdr;
 692      const char *name;
 693 {
 694   asection *newsect;
 695   flagword flags;
 696   struct elf_backend_data *bed;
 697
 698   if (hdr->bfd_section != NULL)
 699     {
 700       BFD_ASSERT (strcmp (name,
 701                           bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
 702       return true;
 703     }
 704
 705   newsect = bfd_make_section_anyway (abfd, name);
 706   if (newsect == NULL)
 707     return false;
 708
 709   newsect->filepos = hdr->sh_offset;
 710
 711   if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
 712       || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
 713       || ! bfd_set_section_alignment (abfd, newsect,
 714                                       bfd_log2 ((bfd_vma) hdr->sh_addralign)))
 715     return false;
 716
 717   flags = SEC_NO_FLAGS;
 718   if (hdr->sh_type != SHT_NOBITS)
 719     flags |= SEC_HAS_CONTENTS;
 720   if (hdr->sh_type == SHT_GROUP)
 721     flags |= SEC_GROUP | SEC_EXCLUDE;
 722   if ((hdr->sh_flags & SHF_ALLOC) != 0)
 723     {
 724       flags |= SEC_ALLOC;
 725       if (hdr->sh_type != SHT_NOBITS)
 726         flags |= SEC_LOAD;
 727     }
 728   if ((hdr->sh_flags & SHF_WRITE) == 0)
 729     flags |= SEC_READONLY;
 730   if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
 731     flags |= SEC_CODE;
 732   else if ((flags & SEC_LOAD) != 0)
 733     flags |= SEC_DATA;
 734   if ((hdr->sh_flags & SHF_MERGE) != 0)
 735     {
 736       flags |= SEC_MERGE;
 737       newsect->entsize = hdr->sh_entsize;
 738       if ((hdr->sh_flags & SHF_STRINGS) != 0)
 739         flags |= SEC_STRINGS;
 740     }
 741   if (hdr->sh_flags & SHF_GROUP)
 742     if (!setup_group (abfd, hdr, newsect))
 743       return false;
 744   if ((hdr->sh_flags & SHF_TLS) != 0)
 745     flags |= SEC_THREAD_LOCAL;
 746
 747   /* The debugging sections appear to be recognized only by name, not
 748      any sort of flag.  */
 749   {
 750     static const char *debug_sec_names [] =
 751     {
 752       ".debug",
 753       ".gnu.linkonce.wi.",
 754       ".line",
 755       ".stab"
 756     };
 757     int i;
 758
 759     for (i = ARRAY_SIZE (debug_sec_names); i--;)
 760       if (strncmp (name, debug_sec_names[i], strlen (debug_sec_names[i])) == 0)
 761         break;
 762
 763     if (i >= 0)
 764       flags |= SEC_DEBUGGING;
 765   }
 766
 767   /* As a GNU extension, if the name begins with .gnu.linkonce, we
 768      only link a single copy of the section.  This is used to support
 769      g++.  g++ will emit each template expansion in its own section.
 770      The symbols will be defined as weak, so that multiple definitions
 771      are permitted.  The GNU linker extension is to actually discard
 772      all but one of the sections.  */
 773   if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
 774       && elf_next_in_group (newsect) == NULL)
 775     flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 776
 777   bed = get_elf_backend_data (abfd);
 778   if (bed->elf_backend_section_flags)
 779     if (! bed->elf_backend_section_flags (&flags, hdr))
 780       return false;
 781
 782   if (! bfd_set_section_flags (abfd, newsect, flags))
 783     return false;
 784
 785   if ((flags & SEC_ALLOC) != 0)
 786     {
 787       Elf_Internal_Phdr *phdr;
 788       unsigned int i;
 789
 790       /* Look through the phdrs to see if we need to adjust the lma.
 791          If all the p_paddr fields are zero, we ignore them, since
 792          some ELF linkers produce such output.  */
 793       phdr = elf_tdata (abfd)->phdr;
 794       for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
 795         {
 796           if (phdr->p_paddr != 0)
 797             break;
 798         }
 799       if (i < elf_elfheader (abfd)->e_phnum)
 800         {
 801           phdr = elf_tdata (abfd)->phdr;
 802           for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
 803             {
 804               /* This section is part of this segment if its file
 805                  offset plus size lies within the segment's memory
 806                  span and, if the section is loaded, the extent of the
 807                  loaded data lies within the extent of the segment.
 808
 809                  Note - we used to check the p_paddr field as well, and
 810                  refuse to set the LMA if it was 0.  This is wrong
 811                  though, as a perfectly valid initialised segment can
 812                  have a p_paddr of zero.  Some architectures, eg ARM,
 813                  place special significance on the address 0 and
 814                  executables need to be able to have a segment which
 815                  covers this address.  */
 816               if (phdr->p_type == PT_LOAD
 817                   && (bfd_vma) hdr->sh_offset >= phdr->p_offset
 818                   && (hdr->sh_offset + hdr->sh_size
 819                       <= phdr->p_offset + phdr->p_memsz)
 820                   && ((flags & SEC_LOAD) == 0
 821                       || (hdr->sh_offset + hdr->sh_size
 822                           <= phdr->p_offset + phdr->p_filesz)))
 823                 {
 824                   if ((flags & SEC_LOAD) == 0)
 825                     newsect->lma = (phdr->p_paddr
 826                                     + hdr->sh_addr - phdr->p_vaddr);
 827                   else
 828                     /* We used to use the same adjustment for SEC_LOAD
 829                        sections, but that doesn't work if the segment
 830                        is packed with code from multiple VMAs.
 831                        Instead we calculate the section LMA based on
 832                        the segment LMA.  It is assumed that the
 833                        segment will contain sections with contiguous
 834                        LMAs, even if the VMAs are not.  */
 835                     newsect->lma = (phdr->p_paddr
 836                                     + hdr->sh_offset - phdr->p_offset);
 837
 838                   /* With contiguous segments, we can't tell from file
 839                      offsets whether a section with zero size should
 840                      be placed at the end of one segment or the
 841                      beginning of the next.  Decide based on vaddr.  */
 842                   if (hdr->sh_addr >= phdr->p_vaddr
 843                       && (hdr->sh_addr + hdr->sh_size
 844                           <= phdr->p_vaddr + phdr->p_memsz))
 845                     break;
 846                 }
 847             }
 848         }
 849     }
 850
 851   hdr->bfd_section = newsect;
 852   elf_section_data (newsect)->this_hdr = *hdr;
 853
 854   return true;
 855 }
 856
 857 /*
 858 INTERNAL_FUNCTION
 859         bfd_elf_find_section
 860
 861 SYNOPSIS
 862         struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
 863
 864 DESCRIPTION
 865         Helper functions for GDB to locate the string tables.
 866         Since BFD hides string tables from callers, GDB needs to use an
 867         internal hook to find them.  Sun's .stabstr, in particular,
 868         isn't even pointed to by the .stab section, so ordinary
 869         mechanisms wouldn't work to find it, even if we had some.
 870 */
 871
 872 struct elf_internal_shdr *
 873 bfd_elf_find_section (abfd, name)
 874      bfd *abfd;
 875      char *name;
 876 {
 877   Elf_Internal_Shdr **i_shdrp;
 878   char *shstrtab;
 879   unsigned int max;
 880   unsigned int i;
 881
 882   i_shdrp = elf_elfsections (abfd);
 883   if (i_shdrp != NULL)
 884     {
 885       shstrtab = bfd_elf_get_str_section (abfd,
 886                                           elf_elfheader (abfd)->e_shstrndx);
 887       if (shstrtab != NULL)
 888         {
 889           max = elf_numsections (abfd);
 890           for (i = 1; i < max; i++)
 891             if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
 892               return i_shdrp[i];
 893         }
 894     }
 895   return 0;
 896 }
 897
 898 const char *const bfd_elf_section_type_names[] = {
 899   "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
 900   "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
 901   "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
 902 };
 903
 904 /* ELF relocs are against symbols.  If we are producing relocateable
 905    output, and the reloc is against an external symbol, and nothing
 906    has given us any additional addend, the resulting reloc will also
 907    be against the same symbol.  In such a case, we don't want to
 908    change anything about the way the reloc is handled, since it will
 909    all be done at final link time.  Rather than put special case code
 910    into bfd_perform_relocation, all the reloc types use this howto
 911    function.  It just short circuits the reloc if producing
 912    relocateable output against an external symbol.  */
 913
 914 bfd_reloc_status_type
 915 bfd_elf_generic_reloc (abfd,
 916                        reloc_entry,
 917                        symbol,
 918                        data,
 919                        input_section,
 920                        output_bfd,
 921                        error_message)
 922      bfd *abfd ATTRIBUTE_UNUSED;
 923      arelent *reloc_entry;
 924      asymbol *symbol;
 925      PTR data ATTRIBUTE_UNUSED;
 926      asection *input_section;
 927      bfd *output_bfd;
 928      char **error_message ATTRIBUTE_UNUSED;
 929 {
 930   if (output_bfd != (bfd *) NULL
 931       && (symbol->flags & BSF_SECTION_SYM) == 0
 932       && (! reloc_entry->howto->partial_inplace
 933           || reloc_entry->addend == 0))
 934     {
 935       reloc_entry->address += input_section->output_offset;
 936       return bfd_reloc_ok;
 937     }
 938
 939   return bfd_reloc_continue;
 940 }
 941 \f
 942 /* Make sure sec_info_type is cleared if sec_info is cleared too.  */
 943
 944 static void
 945 merge_sections_remove_hook (abfd, sec)
 946      bfd *abfd ATTRIBUTE_UNUSED;
 947      asection *sec;
 948 {
 949   struct bfd_elf_section_data *sec_data;
 950
 951   sec_data = elf_section_data (sec);
 952   BFD_ASSERT (sec_data->sec_info_type == ELF_INFO_TYPE_MERGE);
 953   sec_data->sec_info_type = ELF_INFO_TYPE_NONE;
 954 }
 955
 956 /* Finish SHF_MERGE section merging.  */
 957
 958 boolean
 959 _bfd_elf_merge_sections (abfd, info)
 960      bfd *abfd;
 961      struct bfd_link_info *info;
 962 {
 963   if (!is_elf_hash_table (info))
 964     return false;
 965   if (elf_hash_table (info)->merge_info)
 966     _bfd_merge_sections (abfd, elf_hash_table (info)->merge_info,
 967                          merge_sections_remove_hook);
 968   return true;
 969 }
 970
 971 void
 972 _bfd_elf_link_just_syms (sec, info)
 973      asection *sec;
 974      struct bfd_link_info *info;
 975 {
 976   sec->output_section = bfd_abs_section_ptr;
 977   sec->output_offset = sec->vma;
 978   if (!is_elf_hash_table (info))
 979     return;
 980
 981   elf_section_data (sec)->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
 982 }
 983 \f
 984 /* Copy the program header and other data from one object module to
 985    another.  */
 986
 987 boolean
 988 _bfd_elf_copy_private_bfd_data (ibfd, obfd)
 989      bfd *ibfd;
 990      bfd *obfd;
 991 {
 992   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 993       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 994     return true;
 995
 996   BFD_ASSERT (!elf_flags_init (obfd)
 997               || (elf_elfheader (obfd)->e_flags
 998                   == elf_elfheader (ibfd)->e_flags));
 999
1000   elf_gp (obfd) = elf_gp (ibfd);
1001   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1002   elf_flags_init (obfd) = true;
1003   return true;
1004 }
1005
1006 /* Print out the program headers.  */
1007
1008 boolean
1009 _bfd_elf_print_private_bfd_data (abfd, farg)
1010      bfd *abfd;
1011      PTR farg;
1012 {
1013   FILE *f = (FILE *) farg;
1014   Elf_Internal_Phdr *p;
1015   asection *s;
1016   bfd_byte *dynbuf = NULL;
1017
1018   p = elf_tdata (abfd)->phdr;
1019   if (p != NULL)
1020     {
1021       unsigned int i, c;
1022
1023       fprintf (f, _("\nProgram Header:\n"));
1024       c = elf_elfheader (abfd)->e_phnum;
1025       for (i = 0; i < c; i++, p++)
1026         {
1027           const char *pt;
1028           char buf[20];
1029
1030           switch (p->p_type)
1031             {
1032             case PT_NULL: pt = "NULL"; break;
1033             case PT_LOAD: pt = "LOAD"; break;
1034             case PT_DYNAMIC: pt = "DYNAMIC"; break;
1035             case PT_INTERP: pt = "INTERP"; break;
1036             case PT_NOTE: pt = "NOTE"; break;
1037             case PT_SHLIB: pt = "SHLIB"; break;
1038             case PT_PHDR: pt = "PHDR"; break;
1039             case PT_TLS: pt = "TLS"; break;
1040             case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1041             default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
1042             }
1043           fprintf (f, "%8s off    0x", pt);
1044           bfd_fprintf_vma (abfd, f, p->p_offset);
1045           fprintf (f, " vaddr 0x");
1046           bfd_fprintf_vma (abfd, f, p->p_vaddr);
1047           fprintf (f, " paddr 0x");
1048           bfd_fprintf_vma (abfd, f, p->p_paddr);
1049           fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1050           fprintf (f, "         filesz 0x");
1051           bfd_fprintf_vma (abfd, f, p->p_filesz);
1052           fprintf (f, " memsz 0x");
1053           bfd_fprintf_vma (abfd, f, p->p_memsz);
1054           fprintf (f, " flags %c%c%c",
1055                    (p->p_flags & PF_R) != 0 ? 'r' : '-',
1056                    (p->p_flags & PF_W) != 0 ? 'w' : '-',
1057                    (p->p_flags & PF_X) != 0 ? 'x' : '-');
1058           if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1059             fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1060           fprintf (f, "\n");
1061         }
1062     }
1063
1064   s = bfd_get_section_by_name (abfd, ".dynamic");
1065   if (s != NULL)
1066     {
1067       int elfsec;
1068       unsigned long shlink;
1069       bfd_byte *extdyn, *extdynend;
1070       size_t extdynsize;
1071       void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1072
1073       fprintf (f, _("\nDynamic Section:\n"));
1074
1075       dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1076       if (dynbuf == NULL)
1077         goto error_return;
1078       if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1079                                       s->_raw_size))
1080         goto error_return;
1081
1082       elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1083       if (elfsec == -1)
1084         goto error_return;
1085       shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1086
1087       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1088       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1089
1090       extdyn = dynbuf;
1091       extdynend = extdyn + s->_raw_size;
1092       for (; extdyn < extdynend; extdyn += extdynsize)
1093         {
1094           Elf_Internal_Dyn dyn;
1095           const char *name;
1096           char ab[20];
1097           boolean stringp;
1098
1099           (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1100
1101           if (dyn.d_tag == DT_NULL)
1102             break;
1103
1104           stringp = false;
1105           switch (dyn.d_tag)
1106             {
1107             default:
1108               sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1109               name = ab;
1110               break;
1111
1112             case DT_NEEDED: name = "NEEDED"; stringp = true; break;
1113             case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1114             case DT_PLTGOT: name = "PLTGOT"; break;
1115             case DT_HASH: name = "HASH"; break;
1116             case DT_STRTAB: name = "STRTAB"; break;
1117             case DT_SYMTAB: name = "SYMTAB"; break;
1118             case DT_RELA: name = "RELA"; break;
1119             case DT_RELASZ: name = "RELASZ"; break;
1120             case DT_RELAENT: name = "RELAENT"; break;
1121             case DT_STRSZ: name = "STRSZ"; break;
1122             case DT_SYMENT: name = "SYMENT"; break;
1123             case DT_INIT: name = "INIT"; break;
1124             case DT_FINI: name = "FINI"; break;
1125             case DT_SONAME: name = "SONAME"; stringp = true; break;
1126             case DT_RPATH: name = "RPATH"; stringp = true; break;
1127             case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1128             case DT_REL: name = "REL"; break;
1129             case DT_RELSZ: name = "RELSZ"; break;
1130             case DT_RELENT: name = "RELENT"; break;
1131             case DT_PLTREL: name = "PLTREL"; break;
1132             case DT_DEBUG: name = "DEBUG"; break;
1133             case DT_TEXTREL: name = "TEXTREL"; break;
1134             case DT_JMPREL: name = "JMPREL"; break;
1135             case DT_BIND_NOW: name = "BIND_NOW"; break;
1136             case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1137             case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1138             case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1139             case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1140             case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
1141             case DT_FLAGS: name = "FLAGS"; break;
1142             case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1143             case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1144             case DT_CHECKSUM: name = "CHECKSUM"; break;
1145             case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1146             case DT_MOVEENT: name = "MOVEENT"; break;
1147             case DT_MOVESZ: name = "MOVESZ"; break;
1148             case DT_FEATURE: name = "FEATURE"; break;
1149             case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1150             case DT_SYMINSZ: name = "SYMINSZ"; break;
1151             case DT_SYMINENT: name = "SYMINENT"; break;
1152             case DT_CONFIG: name = "CONFIG"; stringp = true; break;
1153             case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
1154             case DT_AUDIT: name = "AUDIT"; stringp = true; break;
1155             case DT_PLTPAD: name = "PLTPAD"; break;
1156             case DT_MOVETAB: name = "MOVETAB"; break;
1157             case DT_SYMINFO: name = "SYMINFO"; break;
1158             case DT_RELACOUNT: name = "RELACOUNT"; break;
1159             case DT_RELCOUNT: name = "RELCOUNT"; break;
1160             case DT_FLAGS_1: name = "FLAGS_1"; break;
1161             case DT_VERSYM: name = "VERSYM"; break;
1162             case DT_VERDEF: name = "VERDEF"; break;
1163             case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1164             case DT_VERNEED: name = "VERNEED"; break;
1165             case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1166             case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
1167             case DT_USED: name = "USED"; break;
1168             case DT_FILTER: name = "FILTER"; stringp = true; break;
1169             }
1170
1171           fprintf (f, "  %-11s ", name);
1172           if (! stringp)
1173             fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1174           else
1175             {
1176               const char *string;
1177               unsigned int tagv = dyn.d_un.d_val;
1178
1179               string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1180               if (string == NULL)
1181                 goto error_return;
1182               fprintf (f, "%s", string);
1183             }
1184           fprintf (f, "\n");
1185         }
1186
1187       free (dynbuf);
1188       dynbuf = NULL;
1189     }
1190
1191   if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1192       || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1193     {
1194       if (! _bfd_elf_slurp_version_tables (abfd))
1195         return false;
1196     }
1197
1198   if (elf_dynverdef (abfd) != 0)
1199     {
1200       Elf_Internal_Verdef *t;
1201
1202       fprintf (f, _("\nVersion definitions:\n"));
1203       for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1204         {
1205           fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1206                    t->vd_flags, t->vd_hash, t->vd_nodename);
1207           if (t->vd_auxptr->vda_nextptr != NULL)
1208             {
1209               Elf_Internal_Verdaux *a;
1210
1211               fprintf (f, "\t");
1212               for (a = t->vd_auxptr->vda_nextptr;
1213                    a != NULL;
1214                    a = a->vda_nextptr)
1215                 fprintf (f, "%s ", a->vda_nodename);
1216               fprintf (f, "\n");
1217             }
1218         }
1219     }
1220
1221   if (elf_dynverref (abfd) != 0)
1222     {
1223       Elf_Internal_Verneed *t;
1224
1225       fprintf (f, _("\nVersion References:\n"));
1226       for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1227         {
1228           Elf_Internal_Vernaux *a;
1229
1230           fprintf (f, _("  required from %s:\n"), t->vn_filename);
1231           for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1232             fprintf (f, "    0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1233                      a->vna_flags, a->vna_other, a->vna_nodename);
1234         }
1235     }
1236
1237   return true;
1238
1239  error_return:
1240   if (dynbuf != NULL)
1241     free (dynbuf);
1242   return false;
1243 }
1244
1245 /* Display ELF-specific fields of a symbol.  */
1246
1247 void
1248 bfd_elf_print_symbol (abfd, filep, symbol, how)
1249      bfd *abfd;
1250      PTR filep;
1251      asymbol *symbol;
1252      bfd_print_symbol_type how;
1253 {
1254   FILE *file = (FILE *) filep;
1255   switch (how)
1256     {
1257     case bfd_print_symbol_name:
1258       fprintf (file, "%s", symbol->name);
1259       break;
1260     case bfd_print_symbol_more:
1261       fprintf (file, "elf ");
1262       bfd_fprintf_vma (abfd, file, symbol->value);
1263       fprintf (file, " %lx", (long) symbol->flags);
1264       break;
1265     case bfd_print_symbol_all:
1266       {
1267         const char *section_name;
1268         const char *name = NULL;
1269         struct elf_backend_data *bed;
1270         unsigned char st_other;
1271         bfd_vma val;
1272
1273         section_name = symbol->section ? symbol->section->name : "(*none*)";
1274
1275         bed = get_elf_backend_data (abfd);
1276         if (bed->elf_backend_print_symbol_all)
1277           name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1278
1279         if (name == NULL)
1280           {
1281             name = symbol->name;
1282             bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
1283           }
1284
1285         fprintf (file, " %s\t", section_name);
1286         /* Print the "other" value for a symbol.  For common symbols,
1287            we've already printed the size; now print the alignment.
1288            For other symbols, we have no specified alignment, and
1289            we've printed the address; now print the size.  */
1290         if (bfd_is_com_section (symbol->section))
1291           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1292         else
1293           val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1294         bfd_fprintf_vma (abfd, file, val);
1295
1296         /* If we have version information, print it.  */
1297         if (elf_tdata (abfd)->dynversym_section != 0
1298             && (elf_tdata (abfd)->dynverdef_section != 0
1299                 || elf_tdata (abfd)->dynverref_section != 0))
1300           {
1301             unsigned int vernum;
1302             const char *version_string;
1303
1304             vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1305
1306             if (vernum == 0)
1307               version_string = "";
1308             else if (vernum == 1)
1309               version_string = "Base";
1310             else if (vernum <= elf_tdata (abfd)->cverdefs)
1311               version_string =
1312                 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1313             else
1314               {
1315                 Elf_Internal_Verneed *t;
1316
1317                 version_string = "";
1318                 for (t = elf_tdata (abfd)->verref;
1319                      t != NULL;
1320                      t = t->vn_nextref)
1321                   {
1322                     Elf_Internal_Vernaux *a;
1323
1324                     for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1325                       {
1326                         if (a->vna_other == vernum)
1327                           {
1328                             version_string = a->vna_nodename;
1329                             break;
1330                           }
1331                       }
1332                   }
1333               }
1334
1335             if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1336               fprintf (file, "  %-11s", version_string);
1337             else
1338               {
1339                 int i;
1340
1341                 fprintf (file, " (%s)", version_string);
1342                 for (i = 10 - strlen (version_string); i > 0; --i)
1343                   putc (' ', file);
1344               }
1345           }
1346
1347         /* If the st_other field is not zero, print it.  */
1348         st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1349
1350         switch (st_other)
1351           {
1352           case 0: break;
1353           case STV_INTERNAL:  fprintf (file, " .internal");  break;
1354           case STV_HIDDEN:    fprintf (file, " .hidden");    break;
1355           case STV_PROTECTED: fprintf (file, " .protected"); break;
1356           default:
1357             /* Some other non-defined flags are also present, so print
1358                everything hex.  */
1359             fprintf (file, " 0x%02x", (unsigned int) st_other);
1360           }
1361
1362         fprintf (file, " %s", name);
1363       }
1364       break;
1365     }
1366 }
1367 \f
1368 /* Create an entry in an ELF linker hash table.  */
1369
1370 struct bfd_hash_entry *
1371 _bfd_elf_link_hash_newfunc (entry, table, string)
1372      struct bfd_hash_entry *entry;
1373      struct bfd_hash_table *table;
1374      const char *string;
1375 {
1376   /* Allocate the structure if it has not already been allocated by a
1377      subclass.  */
1378   if (entry == NULL)
1379     {
1380       entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1381       if (entry == NULL)
1382         return entry;
1383     }
1384
1385   /* Call the allocation method of the superclass.  */
1386   entry = _bfd_link_hash_newfunc (entry, table, string);
1387   if (entry != NULL)
1388     {
1389       struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1390       struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1391
1392       /* Set local fields.  */
1393       ret->indx = -1;
1394       ret->size = 0;
1395       ret->dynindx = -1;
1396       ret->dynstr_index = 0;
1397       ret->weakdef = NULL;
1398       ret->got.refcount = htab->init_refcount;
1399       ret->plt.refcount = htab->init_refcount;
1400       ret->linker_section_pointer = NULL;
1401       ret->verinfo.verdef = NULL;
1402       ret->vtable_entries_used = NULL;
1403       ret->vtable_entries_size = 0;
1404       ret->vtable_parent = NULL;
1405       ret->type = STT_NOTYPE;
1406       ret->other = 0;
1407       /* Assume that we have been called by a non-ELF symbol reader.
1408          This flag is then reset by the code which reads an ELF input
1409          file.  This ensures that a symbol created by a non-ELF symbol
1410          reader will have the flag set correctly.  */
1411       ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
1412     }
1413
1414   return entry;
1415 }
1416
1417 /* Copy data from an indirect symbol to its direct symbol, hiding the
1418    old indirect symbol.  Also used for copying flags to a weakdef.  */
1419
1420 void
1421 _bfd_elf_link_hash_copy_indirect (bed, dir, ind)
1422      struct elf_backend_data *bed;
1423      struct elf_link_hash_entry *dir, *ind;
1424 {
1425   bfd_signed_vma tmp;
1426   bfd_signed_vma lowest_valid = bed->can_refcount;
1427
1428   /* Copy down any references that we may have already seen to the
1429      symbol which just became indirect.  */
1430
1431   dir->elf_link_hash_flags |=
1432     (ind->elf_link_hash_flags
1433      & (ELF_LINK_HASH_REF_DYNAMIC
1434         | ELF_LINK_HASH_REF_REGULAR
1435         | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1436         | ELF_LINK_NON_GOT_REF));
1437
1438   if (ind->root.type != bfd_link_hash_indirect)
1439     return;
1440
1441   /* Copy over the global and procedure linkage table refcount entries.
1442      These may have been already set up by a check_relocs routine.  */
1443   tmp = dir->got.refcount;
1444   if (tmp < lowest_valid)
1445     {
1446       dir->got.refcount = ind->got.refcount;
1447       ind->got.refcount = tmp;
1448     }
1449   else
1450     BFD_ASSERT (ind->got.refcount < lowest_valid);
1451
1452   tmp = dir->plt.refcount;
1453   if (tmp < lowest_valid)
1454     {
1455       dir->plt.refcount = ind->plt.refcount;
1456       ind->plt.refcount = tmp;
1457     }
1458   else
1459     BFD_ASSERT (ind->plt.refcount < lowest_valid);
1460
1461   if (dir->dynindx == -1)
1462     {
1463       dir->dynindx = ind->dynindx;
1464       dir->dynstr_index = ind->dynstr_index;
1465       ind->dynindx = -1;
1466       ind->dynstr_index = 0;
1467     }
1468   else
1469     BFD_ASSERT (ind->dynindx == -1);
1470 }
1471
1472 void
1473 _bfd_elf_link_hash_hide_symbol (info, h, force_local)
1474      struct bfd_link_info *info;
1475      struct elf_link_hash_entry *h;
1476      boolean force_local;
1477 {
1478   h->plt.offset = (bfd_vma) -1;
1479   h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1480   if (force_local)
1481     {
1482       h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
1483       if (h->dynindx != -1)
1484         {
1485           h->dynindx = -1;
1486           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1487                                   h->dynstr_index);
1488         }
1489     }
1490 }
1491
1492 /* Initialize an ELF linker hash table.  */
1493
1494 boolean
1495 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
1496      struct elf_link_hash_table *table;
1497      bfd *abfd;
1498      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
1499                                                 struct bfd_hash_table *,
1500                                                 const char *));
1501 {
1502   boolean ret;
1503
1504   table->dynamic_sections_created = false;
1505   table->dynobj = NULL;
1506   table->init_refcount = get_elf_backend_data (abfd)->can_refcount - 1;
1507   /* The first dynamic symbol is a dummy.  */
1508   table->dynsymcount = 1;
1509   table->dynstr = NULL;
1510   table->bucketcount = 0;
1511   table->needed = NULL;
1512   table->runpath = NULL;
1513   table->loaded = NULL;
1514   table->hgot = NULL;
1515   table->stab_info = NULL;
1516   table->merge_info = NULL;
1517   table->dynlocal = NULL;
1518   ret = _bfd_link_hash_table_init (& table->root, abfd, newfunc);
1519   table->root.type = bfd_link_elf_hash_table;
1520
1521   return ret;
1522 }
1523
1524 /* Create an ELF linker hash table.  */
1525
1526 struct bfd_link_hash_table *
1527 _bfd_elf_link_hash_table_create (abfd)
1528      bfd *abfd;
1529 {
1530   struct elf_link_hash_table *ret;
1531   bfd_size_type amt = sizeof (struct elf_link_hash_table);
1532
1533   ret = (struct elf_link_hash_table *) bfd_malloc (amt);
1534   if (ret == (struct elf_link_hash_table *) NULL)
1535     return NULL;
1536
1537   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1538     {
1539       free (ret);
1540       return NULL;
1541     }
1542
1543   return &ret->root;
1544 }
1545
1546 /* This is a hook for the ELF emulation code in the generic linker to
1547    tell the backend linker what file name to use for the DT_NEEDED
1548    entry for a dynamic object.  The generic linker passes name as an
1549    empty string to indicate that no DT_NEEDED entry should be made.  */
1550
1551 void
1552 bfd_elf_set_dt_needed_name (abfd, name)
1553      bfd *abfd;
1554      const char *name;
1555 {
1556   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1557       && bfd_get_format (abfd) == bfd_object)
1558     elf_dt_name (abfd) = name;
1559 }
1560
1561 void
1562 bfd_elf_set_dt_needed_soname (abfd, name)
1563      bfd *abfd;
1564      const char *name;
1565 {
1566   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1567       && bfd_get_format (abfd) == bfd_object)
1568     elf_dt_soname (abfd) = name;
1569 }
1570
1571 /* Get the list of DT_NEEDED entries for a link.  This is a hook for
1572    the linker ELF emulation code.  */
1573
1574 struct bfd_link_needed_list *
1575 bfd_elf_get_needed_list (abfd, info)
1576      bfd *abfd ATTRIBUTE_UNUSED;
1577      struct bfd_link_info *info;
1578 {
1579   if (info->hash->creator->flavour != bfd_target_elf_flavour)
1580     return NULL;
1581   return elf_hash_table (info)->needed;
1582 }
1583
1584 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link.  This is a
1585    hook for the linker ELF emulation code.  */
1586
1587 struct bfd_link_needed_list *
1588 bfd_elf_get_runpath_list (abfd, info)
1589      bfd *abfd ATTRIBUTE_UNUSED;
1590      struct bfd_link_info *info;
1591 {
1592   if (info->hash->creator->flavour != bfd_target_elf_flavour)
1593     return NULL;
1594   return elf_hash_table (info)->runpath;
1595 }
1596
1597 /* Get the name actually used for a dynamic object for a link.  This
1598    is the SONAME entry if there is one.  Otherwise, it is the string
1599    passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
1600
1601 const char *
1602 bfd_elf_get_dt_soname (abfd)
1603      bfd *abfd;
1604 {
1605   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1606       && bfd_get_format (abfd) == bfd_object)
1607     return elf_dt_name (abfd);
1608   return NULL;
1609 }
1610
1611 /* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
1612    the ELF linker emulation code.  */
1613
1614 boolean
1615 bfd_elf_get_bfd_needed_list (abfd, pneeded)
1616      bfd *abfd;
1617      struct bfd_link_needed_list **pneeded;
1618 {
1619   asection *s;
1620   bfd_byte *dynbuf = NULL;
1621   int elfsec;
1622   unsigned long shlink;
1623   bfd_byte *extdyn, *extdynend;
1624   size_t extdynsize;
1625   void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1626
1627   *pneeded = NULL;
1628
1629   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1630       || bfd_get_format (abfd) != bfd_object)
1631     return true;
1632
1633   s = bfd_get_section_by_name (abfd, ".dynamic");
1634   if (s == NULL || s->_raw_size == 0)
1635     return true;
1636
1637   dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1638   if (dynbuf == NULL)
1639     goto error_return;
1640
1641   if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1642                                   s->_raw_size))
1643     goto error_return;
1644
1645   elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1646   if (elfsec == -1)
1647     goto error_return;
1648
1649   shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1650
1651   extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1652   swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1653
1654   extdyn = dynbuf;
1655   extdynend = extdyn + s->_raw_size;
1656   for (; extdyn < extdynend; extdyn += extdynsize)
1657     {
1658       Elf_Internal_Dyn dyn;
1659
1660       (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1661
1662       if (dyn.d_tag == DT_NULL)
1663         break;
1664
1665       if (dyn.d_tag == DT_NEEDED)
1666         {
1667           const char *string;
1668           struct bfd_link_needed_list *l;
1669           unsigned int tagv = dyn.d_un.d_val;
1670           bfd_size_type amt;
1671
1672           string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1673           if (string == NULL)
1674             goto error_return;
1675
1676           amt = sizeof *l;
1677           l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1678           if (l == NULL)
1679             goto error_return;
1680
1681           l->by = abfd;
1682           l->name = string;
1683           l->next = *pneeded;
1684           *pneeded = l;
1685         }
1686     }
1687
1688   free (dynbuf);
1689
1690   return true;
1691
1692  error_return:
1693   if (dynbuf != NULL)
1694     free (dynbuf);
1695   return false;
1696 }
1697 \f
1698 /* Allocate an ELF string table--force the first byte to be zero.  */
1699
1700 struct bfd_strtab_hash *
1701 _bfd_elf_stringtab_init ()
1702 {
1703   struct bfd_strtab_hash *ret;
1704
1705   ret = _bfd_stringtab_init ();
1706   if (ret != NULL)
1707     {
1708       bfd_size_type loc;
1709
1710       loc = _bfd_stringtab_add (ret, "", true, false);
1711       BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1712       if (loc == (bfd_size_type) -1)
1713         {
1714           _bfd_stringtab_free (ret);
1715           ret = NULL;
1716         }
1717     }
1718   return ret;
1719 }
1720 \f
1721 /* ELF .o/exec file reading */
1722
1723 /* Create a new bfd section from an ELF section header.  */
1724
1725 boolean
1726 bfd_section_from_shdr (abfd, shindex)
1727      bfd *abfd;
1728      unsigned int shindex;
1729 {
1730   Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1731   Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1732   struct elf_backend_data *bed = get_elf_backend_data (abfd);
1733   const char *name;
1734
1735   name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1736
1737   switch (hdr->sh_type)
1738     {
1739     case SHT_NULL:
1740       /* Inactive section. Throw it away.  */
1741       return true;
1742
1743     case SHT_PROGBITS:  /* Normal section with contents.  */
1744     case SHT_NOBITS:    /* .bss section.  */
1745     case SHT_HASH:      /* .hash section.  */
1746     case SHT_NOTE:      /* .note section.  */
1747     case SHT_INIT_ARRAY:        /* .init_array section.  */
1748     case SHT_FINI_ARRAY:        /* .fini_array section.  */
1749     case SHT_PREINIT_ARRAY:     /* .preinit_array section.  */
1750       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1751
1752     case SHT_DYNAMIC:   /* Dynamic linking information.  */
1753       if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1754         return false;
1755       if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1756         {
1757           Elf_Internal_Shdr *dynsymhdr;
1758
1759           /* The shared libraries distributed with hpux11 have a bogus
1760              sh_link field for the ".dynamic" section.  Find the
1761              string table for the ".dynsym" section instead.  */
1762           if (elf_dynsymtab (abfd) != 0)
1763             {
1764               dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1765               hdr->sh_link = dynsymhdr->sh_link;
1766             }
1767           else
1768             {
1769               unsigned int i, num_sec;
1770
1771               num_sec = elf_numsections (abfd);
1772               for (i = 1; i < num_sec; i++)
1773                 {
1774                   dynsymhdr = elf_elfsections (abfd)[i];
1775                   if (dynsymhdr->sh_type == SHT_DYNSYM)
1776                     {
1777                       hdr->sh_link = dynsymhdr->sh_link;
1778                       break;
1779                     }
1780                 }
1781             }
1782         }
1783       break;
1784
1785     case SHT_SYMTAB:            /* A symbol table */
1786       if (elf_onesymtab (abfd) == shindex)
1787         return true;
1788
1789       BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1790       BFD_ASSERT (elf_onesymtab (abfd) == 0);
1791       elf_onesymtab (abfd) = shindex;
1792       elf_tdata (abfd)->symtab_hdr = *hdr;
1793       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1794       abfd->flags |= HAS_SYMS;
1795
1796       /* Sometimes a shared object will map in the symbol table.  If
1797          SHF_ALLOC is set, and this is a shared object, then we also
1798          treat this section as a BFD section.  We can not base the
1799          decision purely on SHF_ALLOC, because that flag is sometimes
1800          set in a relocateable object file, which would confuse the
1801          linker.  */
1802       if ((hdr->sh_flags & SHF_ALLOC) != 0
1803           && (abfd->flags & DYNAMIC) != 0
1804           && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1805         return false;
1806
1807       return true;
1808
1809     case SHT_DYNSYM:            /* A dynamic symbol table */
1810       if (elf_dynsymtab (abfd) == shindex)
1811         return true;
1812
1813       BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1814       BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1815       elf_dynsymtab (abfd) = shindex;
1816       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1817       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1818       abfd->flags |= HAS_SYMS;
1819
1820       /* Besides being a symbol table, we also treat this as a regular
1821          section, so that objcopy can handle it.  */
1822       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1823
1824     case SHT_SYMTAB_SHNDX:      /* Symbol section indices when >64k sections */
1825       if (elf_symtab_shndx (abfd) == shindex)
1826         return true;
1827
1828       /* Get the associated symbol table.  */
1829       if (! bfd_section_from_shdr (abfd, hdr->sh_link)
1830           || hdr->sh_link != elf_onesymtab (abfd))
1831         return false;
1832
1833       elf_symtab_shndx (abfd) = shindex;
1834       elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1835       elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1836       return true;
1837
1838     case SHT_STRTAB:            /* A string table */
1839       if (hdr->bfd_section != NULL)
1840         return true;
1841       if (ehdr->e_shstrndx == shindex)
1842         {
1843           elf_tdata (abfd)->shstrtab_hdr = *hdr;
1844           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1845           return true;
1846         }
1847       {
1848         unsigned int i, num_sec;
1849
1850         num_sec = elf_numsections (abfd);
1851         for (i = 1; i < num_sec; i++)
1852           {
1853             Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1854             if (hdr2->sh_link == shindex)
1855               {
1856                 if (! bfd_section_from_shdr (abfd, i))
1857                   return false;
1858                 if (elf_onesymtab (abfd) == i)
1859                   {
1860                     elf_tdata (abfd)->strtab_hdr = *hdr;
1861                     elf_elfsections (abfd)[shindex] =
1862                       &elf_tdata (abfd)->strtab_hdr;
1863                     return true;
1864                   }
1865                 if (elf_dynsymtab (abfd) == i)
1866                   {
1867                     elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1868                     elf_elfsections (abfd)[shindex] = hdr =
1869                       &elf_tdata (abfd)->dynstrtab_hdr;
1870                     /* We also treat this as a regular section, so
1871                        that objcopy can handle it.  */
1872                     break;
1873                   }
1874 #if 0 /* Not handling other string tables specially right now.  */
1875                 hdr2 = elf_elfsections (abfd)[i];       /* in case it moved */
1876                 /* We have a strtab for some random other section.  */
1877                 newsect = (asection *) hdr2->bfd_section;
1878                 if (!newsect)
1879                   break;
1880                 hdr->bfd_section = newsect;
1881                 hdr2 = &elf_section_data (newsect)->str_hdr;
1882                 *hdr2 = *hdr;
1883                 elf_elfsections (abfd)[shindex] = hdr2;
1884 #endif
1885               }
1886           }
1887       }
1888
1889       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1890
1891     case SHT_REL:
1892     case SHT_RELA:
1893       /* *These* do a lot of work -- but build no sections!  */
1894       {
1895         asection *target_sect;
1896         Elf_Internal_Shdr *hdr2;
1897         unsigned int num_sec = elf_numsections (abfd);
1898
1899         /* Check for a bogus link to avoid crashing.  */
1900         if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1901             || hdr->sh_link >= num_sec)
1902           {
1903             ((*_bfd_error_handler)
1904              (_("%s: invalid link %lu for reloc section %s (index %u)"),
1905               bfd_archive_filename (abfd), hdr->sh_link, name, shindex));
1906             return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1907           }
1908
1909         /* For some incomprehensible reason Oracle distributes
1910            libraries for Solaris in which some of the objects have
1911            bogus sh_link fields.  It would be nice if we could just
1912            reject them, but, unfortunately, some people need to use
1913            them.  We scan through the section headers; if we find only
1914            one suitable symbol table, we clobber the sh_link to point
1915            to it.  I hope this doesn't break anything.  */
1916         if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1917             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1918           {
1919             unsigned int scan;
1920             int found;
1921
1922             found = 0;
1923             for (scan = 1; scan < num_sec; scan++)
1924               {
1925                 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1926                     || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1927                   {
1928                     if (found != 0)
1929                       {
1930                         found = 0;
1931                         break;
1932                       }
1933                     found = scan;
1934                   }
1935               }
1936             if (found != 0)
1937               hdr->sh_link = found;
1938           }
1939
1940         /* Get the symbol table.  */
1941         if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1942             && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1943           return false;
1944
1945         /* If this reloc section does not use the main symbol table we
1946            don't treat it as a reloc section.  BFD can't adequately
1947            represent such a section, so at least for now, we don't
1948            try.  We just present it as a normal section.  We also
1949            can't use it as a reloc section if it points to the null
1950            section.  */
1951         if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1952           return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1953
1954         if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1955           return false;
1956         target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1957         if (target_sect == NULL)
1958           return false;
1959
1960         if ((target_sect->flags & SEC_RELOC) == 0
1961             || target_sect->reloc_count == 0)
1962           hdr2 = &elf_section_data (target_sect)->rel_hdr;
1963         else
1964           {
1965             bfd_size_type amt;
1966             BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1967             amt = sizeof (*hdr2);
1968             hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1969             elf_section_data (target_sect)->rel_hdr2 = hdr2;
1970           }
1971         *hdr2 = *hdr;
1972         elf_elfsections (abfd)[shindex] = hdr2;
1973         target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1974         target_sect->flags |= SEC_RELOC;
1975         target_sect->relocation = NULL;
1976         target_sect->rel_filepos = hdr->sh_offset;
1977         /* In the section to which the relocations apply, mark whether
1978            its relocations are of the REL or RELA variety.  */
1979         if (hdr->sh_size != 0)
1980           elf_section_data (target_sect)->use_rela_p
1981             = (hdr->sh_type == SHT_RELA);
1982         abfd->flags |= HAS_RELOC;
1983         return true;
1984       }
1985       break;
1986
1987     case SHT_GNU_verdef:
1988       elf_dynverdef (abfd) = shindex;
1989       elf_tdata (abfd)->dynverdef_hdr = *hdr;
1990       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1991       break;
1992
1993     case SHT_GNU_versym:
1994       elf_dynversym (abfd) = shindex;
1995       elf_tdata (abfd)->dynversym_hdr = *hdr;
1996       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1997       break;
1998
1999     case SHT_GNU_verneed:
2000       elf_dynverref (abfd) = shindex;
2001       elf_tdata (abfd)->dynverref_hdr = *hdr;
2002       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
2003       break;
2004
2005     case SHT_SHLIB:
2006       return true;
2007
2008     case SHT_GROUP:
2009       /* We need a BFD section for objcopy and relocatable linking,
2010          and it's handy to have the signature available as the section
2011          name.  */
2012       name = group_signature (abfd, hdr);
2013       if (name == NULL)
2014         return false;
2015       if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name))
2016         return false;
2017       if (hdr->contents != NULL)
2018         {
2019           Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
2020           unsigned int n_elt = hdr->sh_size / 4;
2021           asection *s;
2022
2023           if (idx->flags & GRP_COMDAT)
2024             hdr->bfd_section->flags
2025               |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2026
2027           while (--n_elt != 0)
2028             if ((s = (++idx)->shdr->bfd_section) != NULL
2029                 && elf_next_in_group (s) != NULL)
2030               {
2031                 elf_next_in_group (hdr->bfd_section) = s;
2032                 break;
2033               }
2034         }
2035       break;
2036
2037     default:
2038       /* Check for any processor-specific section types.  */
2039       {
2040         if (bed->elf_backend_section_from_shdr)
2041           (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
2042       }
2043       break;
2044     }
2045
2046   return true;
2047 }
2048
2049 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2050    Return SEC for sections that have no elf section, and NULL on error.  */
2051
2052 asection *
2053 bfd_section_from_r_symndx (abfd, cache, sec, r_symndx)
2054      bfd *abfd;
2055      struct sym_sec_cache *cache;
2056      asection *sec;
2057      unsigned long r_symndx;
2058 {
2059   Elf_Internal_Shdr *symtab_hdr;
2060   unsigned char esym[sizeof (Elf64_External_Sym)];
2061   Elf_External_Sym_Shndx eshndx;
2062   Elf_Internal_Sym isym;
2063   unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2064
2065   if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
2066     return cache->sec[ent];
2067
2068   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2069   if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2070                             &isym, esym, &eshndx) == NULL)
2071     return NULL;
2072
2073   if (cache->abfd != abfd)
2074     {
2075       memset (cache->indx, -1, sizeof (cache->indx));
2076       cache->abfd = abfd;
2077     }
2078   cache->indx[ent] = r_symndx;
2079   cache->sec[ent] = sec;
2080   if (isym.st_shndx < SHN_LORESERVE || isym.st_shndx > SHN_HIRESERVE)
2081     {
2082       asection *s;
2083       s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2084       if (s != NULL)
2085         cache->sec[ent] = s;
2086     }
2087   return cache->sec[ent];
2088 }
2089
2090 /* Given an ELF section number, retrieve the corresponding BFD
2091    section.  */
2092
2093 asection *
2094 bfd_section_from_elf_index (abfd, index)
2095      bfd *abfd;
2096      unsigned int index;
2097 {
2098   if (index >= elf_numsections (abfd))
2099     return NULL;
2100   return elf_elfsections (abfd)[index]->bfd_section;
2101 }
2102
2103 boolean
2104 _bfd_elf_new_section_hook (abfd, sec)
2105      bfd *abfd;
2106      asection *sec;
2107 {
2108   struct bfd_elf_section_data *sdata;
2109   bfd_size_type amt = sizeof (*sdata);
2110
2111   sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, amt);
2112   if (!sdata)
2113     return false;
2114   sec->used_by_bfd = (PTR) sdata;
2115
2116   /* Indicate whether or not this section should use RELA relocations.  */
2117   sdata->use_rela_p
2118     = get_elf_backend_data (abfd)->default_use_rela_p;
2119
2120   return true;
2121 }
2122
2123 /* Create a new bfd section from an ELF program header.
2124
2125    Since program segments have no names, we generate a synthetic name
2126    of the form segment<NUM>, where NUM is generally the index in the
2127    program header table.  For segments that are split (see below) we
2128    generate the names segment<NUM>a and segment<NUM>b.
2129
2130    Note that some program segments may have a file size that is different than
2131    (less than) the memory size.  All this means is that at execution the
2132    system must allocate the amount of memory specified by the memory size,
2133    but only initialize it with the first "file size" bytes read from the
2134    file.  This would occur for example, with program segments consisting
2135    of combined data+bss.
2136
2137    To handle the above situation, this routine generates TWO bfd sections
2138    for the single program segment.  The first has the length specified by
2139    the file size of the segment, and the second has the length specified
2140    by the difference between the two sizes.  In effect, the segment is split
2141    into it's initialized and uninitialized parts.
2142
2143  */
2144
2145 boolean
2146 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
2147      bfd *abfd;
2148      Elf_Internal_Phdr *hdr;
2149      int index;
2150      const char *typename;
2151 {
2152   asection *newsect;
2153   char *name;
2154   char namebuf[64];
2155   size_t len;
2156   int split;
2157
2158   split = ((hdr->p_memsz > 0)
2159             && (hdr->p_filesz > 0)
2160             && (hdr->p_memsz > hdr->p_filesz));
2161   sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2162   len = strlen (namebuf) + 1;
2163   name = bfd_alloc (abfd, (bfd_size_type) len);
2164   if (!name)
2165     return false;
2166   memcpy (name, namebuf, len);
2167   newsect = bfd_make_section (abfd, name);
2168   if (newsect == NULL)
2169     return false;
2170   newsect->vma = hdr->p_vaddr;
2171   newsect->lma = hdr->p_paddr;
2172   newsect->_raw_size = hdr->p_filesz;
2173   newsect->filepos = hdr->p_offset;
2174   newsect->flags |= SEC_HAS_CONTENTS;
2175   if (hdr->p_type == PT_LOAD)
2176     {
2177       newsect->flags |= SEC_ALLOC;
2178       newsect->flags |= SEC_LOAD;
2179       if (hdr->p_flags & PF_X)
2180         {
2181           /* FIXME: all we known is that it has execute PERMISSION,
2182              may be data.  */
2183           newsect->flags |= SEC_CODE;
2184         }
2185     }
2186   if (!(hdr->p_flags & PF_W))
2187     {
2188       newsect->flags |= SEC_READONLY;
2189     }
2190
2191   if (split)
2192     {
2193       sprintf (namebuf, "%s%db", typename, index);
2194       len = strlen (namebuf) + 1;
2195       name = bfd_alloc (abfd, (bfd_size_type) len);
2196       if (!name)
2197         return false;
2198       memcpy (name, namebuf, len);
2199       newsect = bfd_make_section (abfd, name);
2200       if (newsect == NULL)
2201         return false;
2202       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2203       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2204       newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
2205       if (hdr->p_type == PT_LOAD)
2206         {
2207           newsect->flags |= SEC_ALLOC;
2208           if (hdr->p_flags & PF_X)
2209             newsect->flags |= SEC_CODE;
2210         }
2211       if (!(hdr->p_flags & PF_W))
2212         newsect->flags |= SEC_READONLY;
2213     }
2214
2215   return true;
2216 }
2217
2218 boolean
2219 bfd_section_from_phdr (abfd, hdr, index)
2220      bfd *abfd;
2221      Elf_Internal_Phdr *hdr;
2222      int index;
2223 {
2224   struct elf_backend_data *bed;
2225
2226   switch (hdr->p_type)
2227     {
2228     case PT_NULL:
2229       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2230
2231     case PT_LOAD:
2232       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2233
2234     case PT_DYNAMIC:
2235       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2236
2237     case PT_INTERP:
2238       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2239
2240     case PT_NOTE:
2241       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2242         return false;
2243       if (! elfcore_read_notes (abfd, (file_ptr) hdr->p_offset, hdr->p_filesz))
2244         return false;
2245       return true;
2246
2247     case PT_SHLIB:
2248       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2249
2250     case PT_PHDR:
2251       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2252
2253     default:
2254       /* Check for any processor-specific program segment types.
2255          If no handler for them, default to making "segment" sections.  */
2256       bed = get_elf_backend_data (abfd);
2257       if (bed->elf_backend_section_from_phdr)
2258         return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
2259       else
2260         return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
2261     }
2262 }
2263
2264 /* Initialize REL_HDR, the section-header for new section, containing
2265    relocations against ASECT.  If USE_RELA_P is true, we use RELA
2266    relocations; otherwise, we use REL relocations.  */
2267
2268 boolean
2269 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
2270      bfd *abfd;
2271      Elf_Internal_Shdr *rel_hdr;
2272      asection *asect;
2273      boolean use_rela_p;
2274 {
2275   char *name;
2276   struct elf_backend_data *bed = get_elf_backend_data (abfd);
2277   bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2278
2279   name = bfd_alloc (abfd, amt);
2280   if (name == NULL)
2281     return false;
2282   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2283   rel_hdr->sh_name =
2284     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2285                                         false);
2286   if (rel_hdr->sh_name == (unsigned int) -1)
2287     return false;
2288   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2289   rel_hdr->sh_entsize = (use_rela_p
2290                          ? bed->s->sizeof_rela
2291                          : bed->s->sizeof_rel);
2292   rel_hdr->sh_addralign = bed->s->file_align;
2293   rel_hdr->sh_flags = 0;
2294   rel_hdr->sh_addr = 0;
2295   rel_hdr->sh_size = 0;
2296   rel_hdr->sh_offset = 0;
2297
2298   return true;
2299 }
2300
2301 /* Set up an ELF internal section header for a section.  */
2302
2303 static void
2304 elf_fake_sections (abfd, asect, failedptrarg)
2305      bfd *abfd;
2306      asection *asect;
2307      PTR failedptrarg;
2308 {
2309   struct elf_backend_data *bed = get_elf_backend_data (abfd);
2310   boolean *failedptr = (boolean *) failedptrarg;
2311   Elf_Internal_Shdr *this_hdr;
2312
2313   if (*failedptr)
2314     {
2315       /* We already failed; just get out of the bfd_map_over_sections
2316          loop.  */
2317       return;
2318     }
2319
2320   this_hdr = &elf_section_data (asect)->this_hdr;
2321
2322   this_hdr->sh_name = (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2323                                                            asect->name, false);
2324   if (this_hdr->sh_name == (unsigned long) -1)
2325     {
2326       *failedptr = true;
2327       return;
2328     }
2329
2330   this_hdr->sh_flags = 0;
2331
2332   if ((asect->flags & SEC_ALLOC) != 0
2333       || asect->user_set_vma)
2334     this_hdr->sh_addr = asect->vma;
2335   else
2336     this_hdr->sh_addr = 0;
2337
2338   this_hdr->sh_offset = 0;
2339   this_hdr->sh_size = asect->_raw_size;
2340   this_hdr->sh_link = 0;
2341   this_hdr->sh_addralign = 1 << asect->alignment_power;
2342   /* The sh_entsize and sh_info fields may have been set already by
2343      copy_private_section_data.  */
2344
2345   this_hdr->bfd_section = asect;
2346   this_hdr->contents = NULL;
2347
2348   /* FIXME: This should not be based on section names.  */
2349   if (strcmp (asect->name, ".dynstr") == 0)
2350     this_hdr->sh_type = SHT_STRTAB;
2351   else if (strcmp (asect->name, ".hash") == 0)
2352     {
2353       this_hdr->sh_type = SHT_HASH;
2354       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2355     }
2356   else if (strcmp (asect->name, ".dynsym") == 0)
2357     {
2358       this_hdr->sh_type = SHT_DYNSYM;
2359       this_hdr->sh_entsize = bed->s->sizeof_sym;
2360     }
2361   else if (strcmp (asect->name, ".dynamic") == 0)
2362     {
2363       this_hdr->sh_type = SHT_DYNAMIC;
2364       this_hdr->sh_entsize = bed->s->sizeof_dyn;
2365     }
2366   else if (strncmp (asect->name, ".rela", 5) == 0
2367            && get_elf_backend_data (abfd)->may_use_rela_p)
2368     {
2369       this_hdr->sh_type = SHT_RELA;
2370       this_hdr->sh_entsize = bed->s->sizeof_rela;
2371     }
2372   else if (strncmp (asect->name, ".rel", 4) == 0
2373            && get_elf_backend_data (abfd)->may_use_rel_p)
2374     {
2375       this_hdr->sh_type = SHT_REL;
2376       this_hdr->sh_entsize = bed->s->sizeof_rel;
2377     }
2378   else if (strcmp (asect->name, ".init_array") == 0)
2379     this_hdr->sh_type = SHT_INIT_ARRAY;
2380   else if (strcmp (asect->name, ".fini_array") == 0)
2381     this_hdr->sh_type = SHT_FINI_ARRAY;
2382   else if (strcmp (asect->name, ".preinit_array") == 0)
2383     this_hdr->sh_type = SHT_PREINIT_ARRAY;
2384   else if (strncmp (asect->name, ".note", 5) == 0)
2385     this_hdr->sh_type = SHT_NOTE;
2386   else if (strncmp (asect->name, ".stab", 5) == 0
2387            && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
2388     this_hdr->sh_type = SHT_STRTAB;
2389   else if (strcmp (asect->name, ".gnu.version") == 0)
2390     {
2391       this_hdr->sh_type = SHT_GNU_versym;
2392       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2393     }
2394   else if (strcmp (asect->name, ".gnu.version_d") == 0)
2395     {
2396       this_hdr->sh_type = SHT_GNU_verdef;
2397       this_hdr->sh_entsize = 0;
2398       /* objcopy or strip will copy over sh_info, but may not set
2399          cverdefs.  The linker will set cverdefs, but sh_info will be
2400          zero.  */
2401       if (this_hdr->sh_info == 0)
2402         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2403       else
2404         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2405                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2406     }
2407   else if (strcmp (asect->name, ".gnu.version_r") == 0)
2408     {
2409       this_hdr->sh_type = SHT_GNU_verneed;
2410       this_hdr->sh_entsize = 0;
2411       /* objcopy or strip will copy over sh_info, but may not set
2412          cverrefs.  The linker will set cverrefs, but sh_info will be
2413          zero.  */
2414       if (this_hdr->sh_info == 0)
2415         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2416       else
2417         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2418                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2419     }
2420   else if ((asect->flags & SEC_GROUP) != 0)
2421     {
2422       this_hdr->sh_type = SHT_GROUP;
2423       this_hdr->sh_entsize = 4;
2424     }
2425   else if ((asect->flags & SEC_ALLOC) != 0
2426            && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2427                || (asect->flags & SEC_NEVER_LOAD) != 0))
2428     this_hdr->sh_type = SHT_NOBITS;
2429   else
2430     this_hdr->sh_type = SHT_PROGBITS;
2431
2432   if ((asect->flags & SEC_ALLOC) != 0)
2433     this_hdr->sh_flags |= SHF_ALLOC;
2434   if ((asect->flags & SEC_READONLY) == 0)
2435     this_hdr->sh_flags |= SHF_WRITE;
2436   if ((asect->flags & SEC_CODE) != 0)
2437     this_hdr->sh_flags |= SHF_EXECINSTR;
2438   if ((asect->flags & SEC_MERGE) != 0)
2439     {
2440       this_hdr->sh_flags |= SHF_MERGE;
2441       this_hdr->sh_entsize = asect->entsize;
2442       if ((asect->flags & SEC_STRINGS) != 0)
2443         this_hdr->sh_flags |= SHF_STRINGS;
2444     }
2445   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2446     this_hdr->sh_flags |= SHF_GROUP;
2447   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2448     {
2449       this_hdr->sh_flags |= SHF_TLS;
2450       if (asect->_raw_size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2451         {
2452           struct bfd_link_order *o;
2453
2454           this_hdr->sh_size = 0;
2455           for (o = asect->link_order_head; o != NULL; o = o->next)
2456             if (this_hdr->sh_size < o->offset + o->size)
2457               this_hdr->sh_size = o->offset + o->size;
2458           if (this_hdr->sh_size)
2459             this_hdr->sh_type = SHT_NOBITS;
2460         }
2461     }
2462
2463   /* Check for processor-specific section types.  */
2464   if (bed->elf_backend_fake_sections
2465       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2466     *failedptr = true;
2467
2468   /* If the section has relocs, set up a section header for the
2469      SHT_REL[A] section.  If two relocation sections are required for
2470      this section, it is up to the processor-specific back-end to
2471      create the other.  */
2472   if ((asect->flags & SEC_RELOC) != 0
2473       && !_bfd_elf_init_reloc_shdr (abfd,
2474                                     &elf_section_data (asect)->rel_hdr,
2475                                     asect,
2476                                     elf_section_data (asect)->use_rela_p))
2477     *failedptr = true;
2478 }
2479
2480 /* Fill in the contents of a SHT_GROUP section.  */
2481
2482 void
2483 bfd_elf_set_group_contents (abfd, sec, failedptrarg)
2484      bfd *abfd;
2485      asection *sec;
2486      PTR failedptrarg;
2487 {
2488   boolean *failedptr = (boolean *) failedptrarg;
2489   unsigned long symindx;
2490   asection *elt, *first;
2491   unsigned char *loc;
2492   struct bfd_link_order *l;
2493   boolean gas;
2494
2495   if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
2496       || *failedptr)
2497     return;
2498
2499   symindx = 0;
2500   if (elf_group_id (sec) != NULL)
2501     symindx = elf_group_id (sec)->udata.i;
2502
2503   if (symindx == 0)
2504     {
2505       /* If called from the assembler, swap_out_syms will have set up
2506          elf_section_syms;  If called for "ld -r", use target_index.  */
2507       if (elf_section_syms (abfd) != NULL)
2508         symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2509       else
2510         symindx = sec->target_index;
2511     }
2512   elf_section_data (sec)->this_hdr.sh_info = symindx;
2513
2514   /* The contents won't be allocated for "ld -r" or objcopy.  */
2515   gas = true;
2516   if (sec->contents == NULL)
2517     {
2518       gas = false;
2519       sec->contents = bfd_alloc (abfd, sec->_raw_size);
2520
2521       /* Arrange for the section to be written out.  */
2522       elf_section_data (sec)->this_hdr.contents = sec->contents;
2523       if (sec->contents == NULL)
2524         {
2525           *failedptr = true;
2526           return;
2527         }
2528     }
2529
2530   loc = sec->contents + sec->_raw_size;
2531
2532   /* Get the pointer to the first section in the group that gas
2533      squirreled away here.  objcopy arranges for this to be set to the
2534      start of the input section group.  */
2535   first = elt = elf_next_in_group (sec);
2536
2537   /* First element is a flag word.  Rest of section is elf section
2538      indices for all the sections of the group.  Write them backwards
2539      just to keep the group in the same order as given in .section
2540      directives, not that it matters.  */
2541   while (elt != NULL)
2542     {
2543       asection *s;
2544       unsigned int idx;
2545
2546       loc -= 4;
2547       s = elt;
2548       if (!gas)
2549         s = s->output_section;
2550       idx = 0;
2551       if (s != NULL)
2552         idx = elf_section_data (s)->this_idx;
2553       H_PUT_32 (abfd, idx, loc);
2554       elt = elf_next_in_group (elt);
2555       if (elt == first)
2556         break;
2557     }
2558
2559   /* If this is a relocatable link, then the above did nothing because
2560      SEC is the output section.  Look through the input sections
2561      instead.  */
2562   for (l = sec->link_order_head; l != NULL; l = l->next)
2563     if (l->type == bfd_indirect_link_order
2564         && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2565       do
2566         {
2567           loc -= 4;
2568           H_PUT_32 (abfd,
2569                     elf_section_data (elt->output_section)->this_idx, loc);
2570           elt = elf_next_in_group (elt);
2571           /* During a relocatable link, the lists are circular.  */
2572         }
2573       while (elt != elf_next_in_group (l->u.indirect.section));
2574
2575   /* With ld -r, merging SHT_GROUP sections results in wasted space
2576      due to allowing for the flag word on each input.  We may well
2577      duplicate entries too.  */
2578   while ((loc -= 4) > sec->contents)
2579     H_PUT_32 (abfd, 0, loc);
2580
2581   if (loc != sec->contents)
2582     abort ();
2583
2584   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2585 }
2586
2587 /* Assign all ELF section numbers.  The dummy first section is handled here
2588    too.  The link/info pointers for the standard section types are filled
2589    in here too, while we're at it.  */
2590
2591 static boolean
2592 assign_section_numbers (abfd)
2593      bfd *abfd;
2594 {
2595   struct elf_obj_tdata *t = elf_tdata (abfd);
2596   asection *sec;
2597   unsigned int section_number, secn;
2598   Elf_Internal_Shdr **i_shdrp;
2599   bfd_size_type amt;
2600
2601   section_number = 1;
2602
2603   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2604
2605   for (sec = abfd->sections; sec; sec = sec->next)
2606     {
2607       struct bfd_elf_section_data *d = elf_section_data (sec);
2608
2609       if (section_number == SHN_LORESERVE)
2610         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2611       d->this_idx = section_number++;
2612       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2613       if ((sec->flags & SEC_RELOC) == 0)
2614         d->rel_idx = 0;
2615       else
2616         {
2617           if (section_number == SHN_LORESERVE)
2618             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2619           d->rel_idx = section_number++;
2620           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2621         }
2622
2623       if (d->rel_hdr2)
2624         {
2625           if (section_number == SHN_LORESERVE)
2626             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2627           d->rel_idx2 = section_number++;
2628           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2629         }
2630       else
2631         d->rel_idx2 = 0;
2632     }
2633
2634   if (section_number == SHN_LORESERVE)
2635     section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2636   t->shstrtab_section = section_number++;
2637   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2638   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2639
2640   if (bfd_get_symcount (abfd) > 0)
2641     {
2642       if (section_number == SHN_LORESERVE)
2643         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2644       t->symtab_section = section_number++;
2645       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2646       if (section_number > SHN_LORESERVE - 2)
2647         {
2648           if (section_number == SHN_LORESERVE)
2649             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2650           t->symtab_shndx_section = section_number++;
2651           t->symtab_shndx_hdr.sh_name
2652             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2653                                                   ".symtab_shndx", false);
2654           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2655             return false;
2656         }
2657       if (section_number == SHN_LORESERVE)
2658         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2659       t->strtab_section = section_number++;
2660       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2661     }
2662
2663   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2664   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2665
2666   elf_numsections (abfd) = section_number;
2667   elf_elfheader (abfd)->e_shnum = section_number;
2668   if (section_number > SHN_LORESERVE)
2669     elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2670
2671   /* Set up the list of section header pointers, in agreement with the
2672      indices.  */
2673   amt = section_number * sizeof (Elf_Internal_Shdr *);
2674   i_shdrp = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
2675   if (i_shdrp == NULL)
2676     return false;
2677
2678   amt = sizeof (Elf_Internal_Shdr);
2679   i_shdrp[0] = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
2680   if (i_shdrp[0] == NULL)
2681     {
2682       bfd_release (abfd, i_shdrp);
2683       return false;
2684     }
2685   memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
2686
2687   elf_elfsections (abfd) = i_shdrp;
2688
2689   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2690   if (bfd_get_symcount (abfd) > 0)
2691     {
2692       i_shdrp[t->symtab_section] = &t->symtab_hdr;
2693       if (elf_numsections (abfd) > SHN_LORESERVE)
2694         {
2695           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2696           t->symtab_shndx_hdr.sh_link = t->symtab_section;
2697         }
2698       i_shdrp[t->strtab_section] = &t->strtab_hdr;
2699       t->symtab_hdr.sh_link = t->strtab_section;
2700     }
2701   for (sec = abfd->sections; sec; sec = sec->next)
2702     {
2703       struct bfd_elf_section_data *d = elf_section_data (sec);
2704       asection *s;
2705       const char *name;
2706
2707       i_shdrp[d->this_idx] = &d->this_hdr;
2708       if (d->rel_idx != 0)
2709         i_shdrp[d->rel_idx] = &d->rel_hdr;
2710       if (d->rel_idx2 != 0)
2711         i_shdrp[d->rel_idx2] = d->rel_hdr2;
2712
2713       /* Fill in the sh_link and sh_info fields while we're at it.  */
2714
2715       /* sh_link of a reloc section is the section index of the symbol
2716          table.  sh_info is the section index of the section to which
2717          the relocation entries apply.  */
2718       if (d->rel_idx != 0)
2719         {
2720           d->rel_hdr.sh_link = t->symtab_section;
2721           d->rel_hdr.sh_info = d->this_idx;
2722         }
2723       if (d->rel_idx2 != 0)
2724         {
2725           d->rel_hdr2->sh_link = t->symtab_section;
2726           d->rel_hdr2->sh_info = d->this_idx;
2727         }
2728
2729       switch (d->this_hdr.sh_type)
2730         {
2731         case SHT_REL:
2732         case SHT_RELA:
2733           /* A reloc section which we are treating as a normal BFD
2734              section.  sh_link is the section index of the symbol
2735              table.  sh_info is the section index of the section to
2736              which the relocation entries apply.  We assume that an
2737              allocated reloc section uses the dynamic symbol table.
2738              FIXME: How can we be sure?  */
2739           s = bfd_get_section_by_name (abfd, ".dynsym");
2740           if (s != NULL)
2741             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2742
2743           /* We look up the section the relocs apply to by name.  */
2744           name = sec->name;
2745           if (d->this_hdr.sh_type == SHT_REL)
2746             name += 4;
2747           else
2748             name += 5;
2749           s = bfd_get_section_by_name (abfd, name);
2750           if (s != NULL)
2751             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2752           break;
2753
2754         case SHT_STRTAB:
2755           /* We assume that a section named .stab*str is a stabs
2756              string section.  We look for a section with the same name
2757              but without the trailing ``str'', and set its sh_link
2758              field to point to this section.  */
2759           if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
2760               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2761             {
2762               size_t len;
2763               char *alc;
2764
2765               len = strlen (sec->name);
2766               alc = (char *) bfd_malloc ((bfd_size_type) (len - 2));
2767               if (alc == NULL)
2768                 return false;
2769               memcpy (alc, sec->name, len - 3);
2770               alc[len - 3] = '\0';
2771               s = bfd_get_section_by_name (abfd, alc);
2772               free (alc);
2773               if (s != NULL)
2774                 {
2775                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2776
2777                   /* This is a .stab section.  */
2778                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
2779                     elf_section_data (s)->this_hdr.sh_entsize
2780                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
2781                 }
2782             }
2783           break;
2784
2785         case SHT_DYNAMIC:
2786         case SHT_DYNSYM:
2787         case SHT_GNU_verneed:
2788         case SHT_GNU_verdef:
2789           /* sh_link is the section header index of the string table
2790              used for the dynamic entries, or the symbol table, or the
2791              version strings.  */
2792           s = bfd_get_section_by_name (abfd, ".dynstr");
2793           if (s != NULL)
2794             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2795           break;
2796
2797         case SHT_HASH:
2798         case SHT_GNU_versym:
2799           /* sh_link is the section header index of the symbol table
2800              this hash table or version table is for.  */
2801           s = bfd_get_section_by_name (abfd, ".dynsym");
2802           if (s != NULL)
2803             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2804           break;
2805
2806         case SHT_GROUP:
2807           d->this_hdr.sh_link = t->symtab_section;
2808         }
2809     }
2810
2811   for (secn = 1; secn < section_number; ++secn)
2812     if (i_shdrp[secn] == NULL)
2813       i_shdrp[secn] = i_shdrp[0];
2814     else
2815       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
2816                                                        i_shdrp[secn]->sh_name);
2817   return true;
2818 }
2819
2820 /* Map symbol from it's internal number to the external number, moving
2821    all local symbols to be at the head of the list.  */
2822
2823 static INLINE int
2824 sym_is_global (abfd, sym)
2825      bfd *abfd;
2826      asymbol *sym;
2827 {
2828   /* If the backend has a special mapping, use it.  */
2829   if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2830     return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2831             (abfd, sym));
2832
2833   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2834           || bfd_is_und_section (bfd_get_section (sym))
2835           || bfd_is_com_section (bfd_get_section (sym)));
2836 }
2837
2838 static boolean
2839 elf_map_symbols (abfd)
2840      bfd *abfd;
2841 {
2842   unsigned int symcount = bfd_get_symcount (abfd);
2843   asymbol **syms = bfd_get_outsymbols (abfd);
2844   asymbol **sect_syms;
2845   unsigned int num_locals = 0;
2846   unsigned int num_globals = 0;
2847   unsigned int num_locals2 = 0;
2848   unsigned int num_globals2 = 0;
2849   int max_index = 0;
2850   unsigned int idx;
2851   asection *asect;
2852   asymbol **new_syms;
2853   bfd_size_type amt;
2854
2855 #ifdef DEBUG
2856   fprintf (stderr, "elf_map_symbols\n");
2857   fflush (stderr);
2858 #endif
2859
2860   for (asect = abfd->sections; asect; asect = asect->next)
2861     {
2862       if (max_index < asect->index)
2863         max_index = asect->index;
2864     }
2865
2866   max_index++;
2867   amt = max_index * sizeof (asymbol *);
2868   sect_syms = (asymbol **) bfd_zalloc (abfd, amt);
2869   if (sect_syms == NULL)
2870     return false;
2871   elf_section_syms (abfd) = sect_syms;
2872   elf_num_section_syms (abfd) = max_index;
2873
2874   /* Init sect_syms entries for any section symbols we have already
2875      decided to output.  */
2876   for (idx = 0; idx < symcount; idx++)
2877     {
2878       asymbol *sym = syms[idx];
2879
2880       if ((sym->flags & BSF_SECTION_SYM) != 0
2881           && sym->value == 0)
2882         {
2883           asection *sec;
2884
2885           sec = sym->section;
2886
2887           if (sec->owner != NULL)
2888             {
2889               if (sec->owner != abfd)
2890                 {
2891                   if (sec->output_offset != 0)
2892                     continue;
2893
2894                   sec = sec->output_section;
2895
2896                   /* Empty sections in the input files may have had a
2897                      section symbol created for them.  (See the comment
2898                      near the end of _bfd_generic_link_output_symbols in
2899                      linker.c).  If the linker script discards such
2900                      sections then we will reach this point.  Since we know
2901                      that we cannot avoid this case, we detect it and skip
2902                      the abort and the assignment to the sect_syms array.
2903                      To reproduce this particular case try running the
2904                      linker testsuite test ld-scripts/weak.exp for an ELF
2905                      port that uses the generic linker.  */
2906                   if (sec->owner == NULL)
2907                     continue;
2908
2909                   BFD_ASSERT (sec->owner == abfd);
2910                 }
2911               sect_syms[sec->index] = syms[idx];
2912             }
2913         }
2914     }
2915
2916   /* Classify all of the symbols.  */
2917   for (idx = 0; idx < symcount; idx++)
2918     {
2919       if (!sym_is_global (abfd, syms[idx]))
2920         num_locals++;
2921       else
2922         num_globals++;
2923     }
2924
2925   /* We will be adding a section symbol for each BFD section.  Most normal
2926      sections will already have a section symbol in outsymbols, but
2927      eg. SHT_GROUP sections will not, and we need the section symbol mapped
2928      at least in that case.  */
2929   for (asect = abfd->sections; asect; asect = asect->next)
2930     {
2931       if (sect_syms[asect->index] == NULL)
2932         {
2933           if (!sym_is_global (abfd, asect->symbol))
2934             num_locals++;
2935           else
2936             num_globals++;
2937         }
2938     }
2939
2940   /* Now sort the symbols so the local symbols are first.  */
2941   amt = (num_locals + num_globals) * sizeof (asymbol *);
2942   new_syms = (asymbol **) bfd_alloc (abfd, amt);
2943
2944   if (new_syms == NULL)
2945     return false;
2946
2947   for (idx = 0; idx < symcount; idx++)
2948     {
2949       asymbol *sym = syms[idx];
2950       unsigned int i;
2951
2952       if (!sym_is_global (abfd, sym))
2953         i = num_locals2++;
2954       else
2955         i = num_locals + num_globals2++;
2956       new_syms[i] = sym;
2957       sym->udata.i = i + 1;
2958     }
2959   for (asect = abfd->sections; asect; asect = asect->next)
2960     {
2961       if (sect_syms[asect->index] == NULL)
2962         {
2963           asymbol *sym = asect->symbol;
2964           unsigned int i;
2965
2966           sect_syms[asect->index] = sym;
2967           if (!sym_is_global (abfd, sym))
2968             i = num_locals2++;
2969           else
2970             i = num_locals + num_globals2++;
2971           new_syms[i] = sym;
2972           sym->udata.i = i + 1;
2973         }
2974     }
2975
2976   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
2977
2978   elf_num_locals (abfd) = num_locals;
2979   elf_num_globals (abfd) = num_globals;
2980   return true;
2981 }
2982
2983 /* Align to the maximum file alignment that could be required for any
2984    ELF data structure.  */
2985
2986 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
2987 static INLINE file_ptr
2988 align_file_position (off, align)
2989      file_ptr off;
2990      int align;
2991 {
2992   return (off + align - 1) & ~(align - 1);
2993 }
2994
2995 /* Assign a file position to a section, optionally aligning to the
2996    required section alignment.  */
2997
2998 INLINE file_ptr
2999 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
3000      Elf_Internal_Shdr *i_shdrp;
3001      file_ptr offset;
3002      boolean align;
3003 {
3004   if (align)
3005     {
3006       unsigned int al;
3007
3008       al = i_shdrp->sh_addralign;
3009       if (al > 1)
3010         offset = BFD_ALIGN (offset, al);
3011     }
3012   i_shdrp->sh_offset = offset;
3013   if (i_shdrp->bfd_section != NULL)
3014     i_shdrp->bfd_section->filepos = offset;
3015   if (i_shdrp->sh_type != SHT_NOBITS)
3016     offset += i_shdrp->sh_size;
3017   return offset;
3018 }
3019
3020 /* Compute the file positions we are going to put the sections at, and
3021    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3022    is not NULL, this is being called by the ELF backend linker.  */
3023
3024 boolean
3025 _bfd_elf_compute_section_file_positions (abfd, link_info)
3026      bfd *abfd;
3027      struct bfd_link_info *link_info;
3028 {
3029   struct elf_backend_data *bed = get_elf_backend_data (abfd);
3030   boolean failed;
3031   struct bfd_strtab_hash *strtab;
3032   Elf_Internal_Shdr *shstrtab_hdr;
3033
3034   if (abfd->output_has_begun)
3035     return true;
3036
3037   /* Do any elf backend specific processing first.  */
3038   if (bed->elf_backend_begin_write_processing)
3039     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3040
3041   if (! prep_headers (abfd))
3042     return false;
3043
3044   /* Post process the headers if necessary.  */
3045   if (bed->elf_backend_post_process_headers)
3046     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3047
3048   failed = false;
3049   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3050   if (failed)
3051     return false;
3052
3053   if (!assign_section_numbers (abfd))
3054     return false;
3055
3056   /* The backend linker builds symbol table information itself.  */
3057   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3058     {
3059       /* Non-zero if doing a relocatable link.  */
3060       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3061
3062       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3063         return false;
3064     }
3065
3066   if (link_info == NULL)
3067     {
3068       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3069       if (failed)
3070         return false;
3071     }
3072
3073   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3074   /* sh_name was set in prep_headers.  */
3075   shstrtab_hdr->sh_type = SHT_STRTAB;
3076   shstrtab_hdr->sh_flags = 0;
3077   shstrtab_hdr->sh_addr = 0;
3078   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3079   shstrtab_hdr->sh_entsize = 0;
3080   shstrtab_hdr->sh_link = 0;
3081   shstrtab_hdr->sh_info = 0;
3082   /* sh_offset is set in assign_file_positions_except_relocs.  */
3083   shstrtab_hdr->sh_addralign = 1;
3084
3085   if (!assign_file_positions_except_relocs (abfd))
3086     return false;
3087
3088   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3089     {
3090       file_ptr off;
3091       Elf_Internal_Shdr *hdr;
3092
3093       off = elf_tdata (abfd)->next_file_pos;
3094
3095       hdr = &elf_tdata (abfd)->symtab_hdr;
3096       off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3097
3098       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3099       if (hdr->sh_size != 0)
3100         off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3101
3102       hdr = &elf_tdata (abfd)->strtab_hdr;
3103       off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3104
3105       elf_tdata (abfd)->next_file_pos = off;
3106
3107       /* Now that we know where the .strtab section goes, write it
3108          out.  */
3109       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3110           || ! _bfd_stringtab_emit (abfd, strtab))
3111         return false;
3112       _bfd_stringtab_free (strtab);
3113     }
3114
3115   abfd->output_has_begun = true;
3116
3117   return true;
3118 }
3119
3120 /* Create a mapping from a set of sections to a program segment.  */
3121
3122 static INLINE struct elf_segment_map *
3123 make_mapping (abfd, sections, from, to, phdr)
3124      bfd *abfd;
3125      asection **sections;
3126      unsigned int from;
3127      unsigned int to;
3128      boolean phdr;
3129 {
3130   struct elf_segment_map *m;
3131   unsigned int i;
3132   asection **hdrpp;
3133   bfd_size_type amt;
3134
3135   amt = sizeof (struct elf_segment_map);
3136   amt += (to - from - 1) * sizeof (asection *);
3137   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3138   if (m == NULL)
3139     return NULL;
3140   m->next = NULL;
3141   m->p_type = PT_LOAD;
3142   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3143     m->sections[i - from] = *hdrpp;
3144   m->count = to - from;
3145
3146   if (from == 0 && phdr)
3147     {
3148       /* Include the headers in the first PT_LOAD segment.  */
3149       m->includes_filehdr = 1;
3150       m->includes_phdrs = 1;
3151     }
3152
3153   return m;
3154 }
3155
3156 /* Set up a mapping from BFD sections to program segments.  */
3157
3158 static boolean
3159 map_sections_to_segments (abfd)
3160      bfd *abfd;
3161 {
3162   asection **sections = NULL;
3163   asection *s;
3164   unsigned int i;
3165   unsigned int count;
3166   struct elf_segment_map *mfirst;
3167   struct elf_segment_map **pm;
3168   struct elf_segment_map *m;
3169   asection *last_hdr;
3170   unsigned int phdr_index;
3171   bfd_vma maxpagesize;
3172   asection **hdrpp;
3173   boolean phdr_in_segment = true;
3174   boolean writable;
3175   int tls_count = 0;
3176   asection *first_tls = NULL;
3177   asection *dynsec, *eh_frame_hdr;
3178   bfd_size_type amt;
3179
3180   if (elf_tdata (abfd)->segment_map != NULL)
3181     return true;
3182
3183   if (bfd_count_sections (abfd) == 0)
3184     return true;
3185
3186   /* Select the allocated sections, and sort them.  */
3187
3188   amt = bfd_count_sections (abfd) * sizeof (asection *);
3189   sections = (asection **) bfd_malloc (amt);
3190   if (sections == NULL)
3191     goto error_return;
3192
3193   i = 0;
3194   for (s = abfd->sections; s != NULL; s = s->next)
3195     {
3196       if ((s->flags & SEC_ALLOC) != 0)
3197         {
3198           sections[i] = s;
3199           ++i;
3200         }
3201     }
3202   BFD_ASSERT (i <= bfd_count_sections (abfd));
3203   count = i;
3204
3205   qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3206
3207   /* Build the mapping.  */
3208
3209   mfirst = NULL;
3210   pm = &mfirst;
3211
3212   /* If we have a .interp section, then create a PT_PHDR segment for
3213      the program headers and a PT_INTERP segment for the .interp
3214      section.  */
3215   s = bfd_get_section_by_name (abfd, ".interp");
3216   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3217     {
3218       amt = sizeof (struct elf_segment_map);
3219       m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3220       if (m == NULL)
3221         goto error_return;
3222       m->next = NULL;
3223       m->p_type = PT_PHDR;
3224       /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3225       m->p_flags = PF_R | PF_X;
3226       m->p_flags_valid = 1;
3227       m->includes_phdrs = 1;
3228
3229       *pm = m;
3230       pm = &m->next;
3231
3232       amt = sizeof (struct elf_segment_map);
3233       m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3234       if (m == NULL)
3235         goto error_return;
3236       m->next = NULL;
3237       m->p_type = PT_INTERP;
3238       m->count = 1;
3239       m->sections[0] = s;
3240
3241       *pm = m;
3242       pm = &m->next;
3243     }
3244
3245   /* Look through the sections.  We put sections in the same program
3246      segment when the start of the second section can be placed within
3247      a few bytes of the end of the first section.  */
3248   last_hdr = NULL;
3249   phdr_index = 0;
3250   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3251   writable = false;
3252   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3253   if (dynsec != NULL
3254       && (dynsec->flags & SEC_LOAD) == 0)
3255     dynsec = NULL;
3256
3257   /* Deal with -Ttext or something similar such that the first section
3258      is not adjacent to the program headers.  This is an
3259      approximation, since at this point we don't know exactly how many
3260      program headers we will need.  */
3261   if (count > 0)
3262     {
3263       bfd_size_type phdr_size;
3264
3265       phdr_size = elf_tdata (abfd)->program_header_size;
3266       if (phdr_size == 0)
3267         phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3268       if ((abfd->flags & D_PAGED) == 0
3269           || sections[0]->lma < phdr_size
3270           || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3271         phdr_in_segment = false;
3272     }
3273
3274   for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3275     {
3276       asection *hdr;
3277       boolean new_segment;
3278
3279       hdr = *hdrpp;
3280
3281       /* See if this section and the last one will fit in the same
3282          segment.  */
3283
3284       if (last_hdr == NULL)
3285         {
3286           /* If we don't have a segment yet, then we don't need a new
3287              one (we build the last one after this loop).  */
3288           new_segment = false;
3289         }
3290       else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3291         {
3292           /* If this section has a different relation between the
3293              virtual address and the load address, then we need a new
3294              segment.  */
3295           new_segment = true;
3296         }
3297       else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
3298                < BFD_ALIGN (hdr->lma, maxpagesize))
3299         {
3300           /* If putting this section in this segment would force us to
3301              skip a page in the segment, then we need a new segment.  */
3302           new_segment = true;
3303         }
3304       else if ((last_hdr->flags & SEC_LOAD) == 0
3305                && (hdr->flags & SEC_LOAD) != 0)
3306         {
3307           /* We don't want to put a loadable section after a
3308              nonloadable section in the same segment.  */
3309           new_segment = true;
3310         }
3311       else if ((abfd->flags & D_PAGED) == 0)
3312         {
3313           /* If the file is not demand paged, which means that we
3314              don't require the sections to be correctly aligned in the
3315              file, then there is no other reason for a new segment.  */
3316           new_segment = false;
3317         }
3318       else if (! writable
3319                && (hdr->flags & SEC_READONLY) == 0
3320                && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
3321                    == hdr->lma))
3322         {
3323           /* We don't want to put a writable section in a read only
3324              segment, unless they are on the same page in memory
3325              anyhow.  We already know that the last section does not
3326              bring us past the current section on the page, so the
3327              only case in which the new section is not on the same
3328              page as the previous section is when the previous section
3329              ends precisely on a page boundary.  */
3330           new_segment = true;
3331         }
3332       else
3333         {
3334           /* Otherwise, we can use the same segment.  */
3335           new_segment = false;
3336         }
3337
3338       if (! new_segment)
3339         {
3340           if ((hdr->flags & SEC_READONLY) == 0)
3341             writable = true;
3342           last_hdr = hdr;
3343           continue;
3344         }
3345
3346       /* We need a new program segment.  We must create a new program
3347          header holding all the sections from phdr_index until hdr.  */
3348
3349       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3350       if (m == NULL)
3351         goto error_return;
3352
3353       *pm = m;
3354       pm = &m->next;
3355
3356       if ((hdr->flags & SEC_READONLY) == 0)
3357         writable = true;
3358       else
3359         writable = false;
3360
3361       last_hdr = hdr;
3362       phdr_index = i;
3363       phdr_in_segment = false;
3364     }
3365
3366   /* Create a final PT_LOAD program segment.  */
3367   if (last_hdr != NULL)
3368     {
3369       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3370       if (m == NULL)
3371         goto error_return;
3372
3373       *pm = m;
3374       pm = &m->next;
3375     }
3376
3377   /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
3378   if (dynsec != NULL)
3379     {
3380       amt = sizeof (struct elf_segment_map);
3381       m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3382       if (m == NULL)
3383         goto error_return;
3384       m->next = NULL;
3385       m->p_type = PT_DYNAMIC;
3386       m->count = 1;
3387       m->sections[0] = dynsec;
3388
3389       *pm = m;
3390       pm = &m->next;
3391     }
3392
3393   /* For each loadable .note section, add a PT_NOTE segment.  We don't
3394      use bfd_get_section_by_name, because if we link together
3395      nonloadable .note sections and loadable .note sections, we will
3396      generate two .note sections in the output file.  FIXME: Using
3397      names for section types is bogus anyhow.  */
3398   for (s = abfd->sections; s != NULL; s = s->next)
3399     {
3400       if ((s->flags & SEC_LOAD) != 0
3401           && strncmp (s->name, ".note", 5) == 0)
3402         {
3403           amt = sizeof (struct elf_segment_map);
3404           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3405           if (m == NULL)
3406             goto error_return;
3407           m->next = NULL;
3408           m->p_type = PT_NOTE;
3409           m->count = 1;
3410           m->sections[0] = s;
3411
3412           *pm = m;
3413           pm = &m->next;
3414         }
3415       if (s->flags & SEC_THREAD_LOCAL)
3416         {
3417           if (! tls_count)
3418             first_tls = s;
3419           tls_count++;
3420         }
3421     }
3422
3423   /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
3424   if (tls_count > 0)
3425     {
3426       int i;
3427
3428       amt = sizeof (struct elf_segment_map);
3429       amt += (tls_count - 1) * sizeof (asection *);
3430       m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3431       if (m == NULL)
3432         goto error_return;
3433       m->next = NULL;
3434       m->p_type = PT_TLS;
3435       m->count = tls_count;
3436       /* Mandated PF_R.  */
3437       m->p_flags = PF_R;
3438       m->p_flags_valid = 1;
3439       for (i = 0; i < tls_count; ++i)
3440         {
3441           BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3442           m->sections[i] = first_tls;
3443           first_tls = first_tls->next;
3444         }
3445
3446       *pm = m;
3447       pm = &m->next;
3448     }
3449
3450   /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3451      segment.  */
3452   eh_frame_hdr = NULL;
3453   if (elf_tdata (abfd)->eh_frame_hdr)
3454     eh_frame_hdr = bfd_get_section_by_name (abfd, ".eh_frame_hdr");
3455   if (eh_frame_hdr != NULL && (eh_frame_hdr->flags & SEC_LOAD))
3456     {
3457       amt = sizeof (struct elf_segment_map);
3458       m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3459       if (m == NULL)
3460         goto error_return;
3461       m->next = NULL;
3462       m->p_type = PT_GNU_EH_FRAME;
3463       m->count = 1;
3464       m->sections[0] = eh_frame_hdr;
3465
3466       *pm = m;
3467       pm = &m->next;
3468     }
3469
3470   free (sections);
3471   sections = NULL;
3472
3473   elf_tdata (abfd)->segment_map = mfirst;
3474   return true;
3475
3476  error_return:
3477   if (sections != NULL)
3478     free (sections);
3479   return false;
3480 }
3481
3482 /* Sort sections by address.  */
3483
3484 static int
3485 elf_sort_sections (arg1, arg2)
3486      const PTR arg1;
3487      const PTR arg2;
3488 {
3489   const asection *sec1 = *(const asection **) arg1;
3490   const asection *sec2 = *(const asection **) arg2;
3491
3492   /* Sort by LMA first, since this is the address used to
3493      place the section into a segment.  */
3494   if (sec1->lma < sec2->lma)
3495     return -1;
3496   else if (sec1->lma > sec2->lma)
3497     return 1;
3498
3499   /* Then sort by VMA.  Normally the LMA and the VMA will be
3500      the same, and this will do nothing.  */
3501   if (sec1->vma < sec2->vma)
3502     return -1;
3503   else if (sec1->vma > sec2->vma)
3504     return 1;
3505
3506   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
3507
3508 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
3509
3510   if (TOEND (sec1))
3511     {
3512       if (TOEND (sec2))
3513         {
3514           /* If the indicies are the same, do not return 0
3515              here, but continue to try the next comparison.  */
3516           if (sec1->target_index - sec2->target_index != 0)
3517             return sec1->target_index - sec2->target_index;
3518         }
3519       else
3520         return 1;
3521     }
3522   else if (TOEND (sec2))
3523     return -1;
3524
3525 #undef TOEND
3526
3527   /* Sort by size, to put zero sized sections
3528      before others at the same address.  */
3529
3530   if (sec1->_raw_size < sec2->_raw_size)
3531     return -1;
3532   if (sec1->_raw_size > sec2->_raw_size)
3533     return 1;
3534
3535   return sec1->target_index - sec2->target_index;
3536 }
3537
3538 /* Assign file positions to the sections based on the mapping from
3539    sections to segments.  This function also sets up some fields in
3540    the file header, and writes out the program headers.  */
3541
3542 static boolean
3543 assign_file_positions_for_segments (abfd)
3544      bfd *abfd;
3545 {
3546   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3547   unsigned int count;
3548   struct elf_segment_map *m;
3549   unsigned int alloc;
3550   Elf_Internal_Phdr *phdrs;
3551   file_ptr off, voff;
3552   bfd_vma filehdr_vaddr, filehdr_paddr;
3553   bfd_vma phdrs_vaddr, phdrs_paddr;
3554   Elf_Internal_Phdr *p;
3555   bfd_size_type amt;
3556
3557   if (elf_tdata (abfd)->segment_map == NULL)
3558     {
3559       if (! map_sections_to_segments (abfd))
3560         return false;
3561     }
3562   else
3563     {
3564       /* The placement algorithm assumes that non allocated sections are
3565          not in PT_LOAD segments.  We ensure this here by removing such
3566          sections from the segment map.  */
3567       for (m = elf_tdata (abfd)->segment_map;
3568            m != NULL;
3569            m = m->next)
3570         {
3571           unsigned int new_count;
3572           unsigned int i;
3573
3574           if (m->p_type != PT_LOAD)
3575             continue;
3576
3577           new_count = 0;
3578           for (i = 0; i < m->count; i ++)
3579             {
3580               if ((m->sections[i]->flags & SEC_ALLOC) != 0)
3581                 {
3582                   if (i != new_count)
3583                     m->sections[new_count] = m->sections[i];
3584
3585                   new_count ++;
3586                 }
3587             }
3588
3589           if (new_count != m->count)
3590             m->count = new_count;
3591         }
3592     }
3593
3594   if (bed->elf_backend_modify_segment_map)
3595     {
3596       if (! (*bed->elf_backend_modify_segment_map) (abfd))
3597         return false;
3598     }
3599
3600   count = 0;
3601   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3602     ++count;
3603
3604   elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3605   elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3606   elf_elfheader (abfd)->e_phnum = count;
3607
3608   if (count == 0)
3609     return true;
3610
3611   /* If we already counted the number of program segments, make sure
3612      that we allocated enough space.  This happens when SIZEOF_HEADERS
3613      is used in a linker script.  */
3614   alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3615   if (alloc != 0 && count > alloc)
3616     {
3617       ((*_bfd_error_handler)
3618        (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3619         bfd_get_filename (abfd), alloc, count));
3620       bfd_set_error (bfd_error_bad_value);
3621       return false;
3622     }
3623
3624   if (alloc == 0)
3625     alloc = count;
3626
3627   amt = alloc * sizeof (Elf_Internal_Phdr);
3628   phdrs = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
3629   if (phdrs == NULL)
3630     return false;
3631
3632   off = bed->s->sizeof_ehdr;
3633   off += alloc * bed->s->sizeof_phdr;
3634
3635   filehdr_vaddr = 0;
3636   filehdr_paddr = 0;
3637   phdrs_vaddr = 0;
3638   phdrs_paddr = 0;
3639
3640   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3641        m != NULL;
3642        m = m->next, p++)
3643     {
3644       unsigned int i;
3645       asection **secpp;
3646
3647       /* If elf_segment_map is not from map_sections_to_segments, the
3648          sections may not be correctly ordered.  NOTE: sorting should
3649          not be done to the PT_NOTE section of a corefile, which may
3650          contain several pseudo-sections artificially created by bfd.
3651          Sorting these pseudo-sections breaks things badly.  */
3652       if (m->count > 1
3653           && !(elf_elfheader (abfd)->e_type == ET_CORE
3654                && m->p_type == PT_NOTE))
3655         qsort (m->sections, (size_t) m->count, sizeof (asection *),
3656                elf_sort_sections);
3657
3658       p->p_type = m->p_type;
3659       p->p_flags = m->p_flags;
3660
3661       if (p->p_type == PT_LOAD
3662           && m->count > 0
3663           && (m->sections[0]->flags & SEC_ALLOC) != 0)
3664         {
3665           if ((abfd->flags & D_PAGED) != 0)
3666             off += (m->sections[0]->vma - off) % bed->maxpagesize;
3667           else
3668             {
3669               bfd_size_type align;
3670
3671               align = 0;
3672               for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3673                 {
3674                   bfd_size_type secalign;
3675
3676                   secalign = bfd_get_section_alignment (abfd, *secpp);
3677                   if (secalign > align)
3678                     align = secalign;
3679                 }
3680
3681               off += (m->sections[0]->vma - off) % (1 << align);
3682             }
3683         }
3684
3685       if (m->count == 0)
3686         p->p_vaddr = 0;
3687       else
3688         p->p_vaddr = m->sections[0]->vma;
3689
3690       if (m->p_paddr_valid)
3691         p->p_paddr = m->p_paddr;
3692       else if (m->count == 0)
3693         p->p_paddr = 0;
3694       else
3695         p->p_paddr = m->sections[0]->lma;
3696
3697       if (p->p_type == PT_LOAD
3698           && (abfd->flags & D_PAGED) != 0)
3699         p->p_align = bed->maxpagesize;
3700       else if (m->count == 0)
3701         p->p_align = bed->s->file_align;
3702       else
3703         p->p_align = 0;
3704
3705       p->p_offset = 0;
3706       p->p_filesz = 0;
3707       p->p_memsz = 0;
3708
3709       if (m->includes_filehdr)
3710         {
3711           if (! m->p_flags_valid)
3712             p->p_flags |= PF_R;
3713           p->p_offset = 0;
3714           p->p_filesz = bed->s->sizeof_ehdr;
3715           p->p_memsz = bed->s->sizeof_ehdr;
3716           if (m->count > 0)
3717             {
3718               BFD_ASSERT (p->p_type == PT_LOAD);
3719
3720               if (p->p_vaddr < (bfd_vma) off)
3721                 {
3722                   (*_bfd_error_handler)
3723                     (_("%s: Not enough room for program headers, try linking with -N"),
3724                      bfd_get_filename (abfd));
3725                   bfd_set_error (bfd_error_bad_value);
3726                   return false;
3727                 }
3728
3729               p->p_vaddr -= off;
3730               if (! m->p_paddr_valid)
3731                 p->p_paddr -= off;
3732             }
3733           if (p->p_type == PT_LOAD)
3734             {
3735               filehdr_vaddr = p->p_vaddr;
3736               filehdr_paddr = p->p_paddr;
3737             }
3738         }
3739
3740       if (m->includes_phdrs)
3741         {
3742           if (! m->p_flags_valid)
3743             p->p_flags |= PF_R;
3744
3745           if (m->includes_filehdr)
3746             {
3747               if (p->p_type == PT_LOAD)
3748                 {
3749                   phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
3750                   phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
3751                 }
3752             }
3753           else
3754             {
3755               p->p_offset = bed->s->sizeof_ehdr;
3756
3757               if (m->count > 0)
3758                 {
3759                   BFD_ASSERT (p->p_type == PT_LOAD);
3760                   p->p_vaddr -= off - p->p_offset;
3761                   if (! m->p_paddr_valid)
3762                     p->p_paddr -= off - p->p_offset;
3763                 }
3764
3765               if (p->p_type == PT_LOAD)
3766                 {
3767                   phdrs_vaddr = p->p_vaddr;
3768                   phdrs_paddr = p->p_paddr;
3769                 }
3770               else
3771                 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
3772             }
3773
3774           p->p_filesz += alloc * bed->s->sizeof_phdr;
3775           p->p_memsz += alloc * bed->s->sizeof_phdr;
3776         }
3777
3778       if (p->p_type == PT_LOAD
3779           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
3780         {
3781           if (! m->includes_filehdr && ! m->includes_phdrs)
3782             p->p_offset = off;
3783           else
3784             {
3785               file_ptr adjust;
3786
3787               adjust = off - (p->p_offset + p->p_filesz);
3788               p->p_filesz += adjust;
3789               p->p_memsz += adjust;
3790             }
3791         }
3792
3793       voff = off;
3794
3795       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3796         {
3797           asection *sec;
3798           flagword flags;
3799           bfd_size_type align;
3800
3801           sec = *secpp;
3802           flags = sec->flags;
3803           align = 1 << bfd_get_section_alignment (abfd, sec);
3804
3805           /* The section may have artificial alignment forced by a
3806              link script.  Notice this case by the gap between the
3807              cumulative phdr lma and the section's lma.  */
3808           if (p->p_paddr + p->p_memsz < sec->lma)
3809             {
3810               bfd_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
3811
3812               p->p_memsz += adjust;
3813               off += adjust;
3814               voff += adjust;
3815               if ((flags & SEC_LOAD) != 0)
3816                 p->p_filesz += adjust;
3817             }
3818
3819           if (p->p_type == PT_LOAD)
3820             {
3821               bfd_signed_vma adjust;
3822
3823               if ((flags & SEC_LOAD) != 0)
3824                 {
3825                   adjust = sec->lma - (p->p_paddr + p->p_memsz);
3826                   if (adjust < 0)
3827                     adjust = 0;
3828                 }
3829               else if ((flags & SEC_ALLOC) != 0)
3830                 {
3831                   /* The section VMA must equal the file position
3832                      modulo the page size.  FIXME: I'm not sure if
3833                      this adjustment is really necessary.  We used to
3834                      not have the SEC_LOAD case just above, and then
3835                      this was necessary, but now I'm not sure.  */
3836                   if ((abfd->flags & D_PAGED) != 0)
3837                     adjust = (sec->vma - voff) % bed->maxpagesize;
3838                   else
3839                     adjust = (sec->vma - voff) % align;
3840                 }
3841               else
3842                 adjust = 0;
3843
3844               if (adjust != 0)
3845                 {
3846                   if (i == 0)
3847                     {
3848                       (* _bfd_error_handler) (_("\
3849 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3850                                               bfd_section_name (abfd, sec),
3851                                               sec->lma,
3852                                               p->p_paddr);
3853                       return false;
3854                     }
3855                   p->p_memsz += adjust;
3856                   off += adjust;
3857                   voff += adjust;
3858                   if ((flags & SEC_LOAD) != 0)
3859                     p->p_filesz += adjust;
3860                 }
3861
3862               sec->filepos = off;
3863
3864               /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3865                  used in a linker script we may have a section with
3866                  SEC_LOAD clear but which is supposed to have
3867                  contents.  */
3868               if ((flags & SEC_LOAD) != 0
3869                   || (flags & SEC_HAS_CONTENTS) != 0)
3870                 off += sec->_raw_size;
3871
3872               if ((flags & SEC_ALLOC) != 0)
3873                 voff += sec->_raw_size;
3874             }
3875
3876           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
3877             {
3878               /* The actual "note" segment has i == 0.
3879                  This is the one that actually contains everything.  */
3880               if (i == 0)
3881                 {
3882                   sec->filepos = off;
3883                   p->p_filesz = sec->_raw_size;
3884                   off += sec->_raw_size;
3885                   voff = off;
3886                 }
3887               else
3888                 {
3889                   /* Fake sections -- don't need to be written.  */
3890                   sec->filepos = 0;
3891                   sec->_raw_size = 0;
3892                   flags = sec->flags = 0;
3893                 }
3894               p->p_memsz = 0;
3895               p->p_align = 1;
3896             }
3897           else
3898             {
3899               p->p_memsz += sec->_raw_size;
3900
3901               if ((flags & SEC_LOAD) != 0)
3902                 p->p_filesz += sec->_raw_size;
3903
3904               if (p->p_type == PT_TLS
3905                   && sec->_raw_size == 0
3906                   && (sec->flags & SEC_HAS_CONTENTS) == 0)
3907                 {
3908                   struct bfd_link_order *o;
3909                   bfd_vma tbss_size = 0;
3910
3911                   for (o = sec->link_order_head; o != NULL; o = o->next)
3912                     if (tbss_size < o->offset + o->size)
3913                       tbss_size = o->offset + o->size;
3914
3915                   p->p_memsz += tbss_size;
3916                 }
3917
3918               if (align > p->p_align
3919                   && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
3920                 p->p_align = align;
3921             }
3922
3923           if (! m->p_flags_valid)
3924             {
3925               p->p_flags |= PF_R;
3926               if ((flags & SEC_CODE) != 0)
3927                 p->p_flags |= PF_X;
3928               if ((flags & SEC_READONLY) == 0)
3929                 p->p_flags |= PF_W;
3930             }
3931         }
3932     }
3933
3934   /* Now that we have set the section file positions, we can set up
3935      the file positions for the non PT_LOAD segments.  */
3936   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3937        m != NULL;
3938        m = m->next, p++)
3939     {
3940       if (p->p_type != PT_LOAD && m->count > 0)
3941         {
3942           BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
3943           p->p_offset = m->sections[0]->filepos;
3944         }
3945       if (m->count == 0)
3946         {
3947           if (m->includes_filehdr)
3948             {
3949               p->p_vaddr = filehdr_vaddr;
3950               if (! m->p_paddr_valid)
3951                 p->p_paddr = filehdr_paddr;
3952             }
3953           else if (m->includes_phdrs)
3954             {
3955               p->p_vaddr = phdrs_vaddr;
3956               if (! m->p_paddr_valid)
3957                 p->p_paddr = phdrs_paddr;
3958             }
3959         }
3960     }
3961
3962   /* If additional nonloadable filepos adjustments are required,
3963      do them now. */
3964   if (bed->set_nonloadable_filepos)
3965     (*bed->set_nonloadable_filepos) (abfd, phdrs);
3966
3967   /* Clear out any program headers we allocated but did not use.  */
3968   for (; count < alloc; count++, p++)
3969     {
3970       memset (p, 0, sizeof *p);
3971       p->p_type = PT_NULL;
3972     }
3973
3974   elf_tdata (abfd)->phdr = phdrs;
3975
3976   elf_tdata (abfd)->next_file_pos = off;
3977
3978   /* Write out the program headers.  */
3979   if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
3980       || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
3981     return false;
3982
3983   return true;
3984 }
3985
3986 /* Get the size of the program header.
3987
3988    If this is called by the linker before any of the section VMA's are set, it
3989    can't calculate the correct value for a strange memory layout.  This only
3990    happens when SIZEOF_HEADERS is used in a linker script.  In this case,
3991    SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3992    data segment (exclusive of .interp and .dynamic).
3993
3994    ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3995    will be two segments.  */
3996
3997 static bfd_size_type
3998 get_program_header_size (abfd)
3999      bfd *abfd;
4000 {
4001   size_t segs;
4002   asection *s;
4003   struct elf_backend_data *bed = get_elf_backend_data (abfd);
4004
4005   /* We can't return a different result each time we're called.  */
4006   if (elf_tdata (abfd)->program_header_size != 0)
4007     return elf_tdata (abfd)->program_header_size;
4008
4009   if (elf_tdata (abfd)->segment_map != NULL)
4010     {
4011       struct elf_segment_map *m;
4012
4013       segs = 0;
4014       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4015         ++segs;
4016       elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4017       return elf_tdata (abfd)->program_header_size;
4018     }
4019
4020   /* Assume we will need exactly two PT_LOAD segments: one for text
4021      and one for data.  */
4022   segs = 2;
4023
4024   s = bfd_get_section_by_name (abfd, ".interp");
4025   if (s != NULL && (s->flags & SEC_LOAD) != 0)
4026     {
4027       /* If we have a loadable interpreter section, we need a
4028          PT_INTERP segment.  In this case, assume we also need a
4029          PT_PHDR segment, although that may not be true for all
4030          targets.  */
4031       segs += 2;
4032     }
4033
4034   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4035     {
4036       /* We need a PT_DYNAMIC segment.  */
4037       ++segs;
4038     }
4039
4040   if (elf_tdata (abfd)->eh_frame_hdr
4041       && bfd_get_section_by_name (abfd, ".eh_frame_hdr") != NULL)
4042     {
4043       /* We need a PT_GNU_EH_FRAME segment.  */
4044       ++segs;
4045     }
4046
4047   for (s = abfd->sections; s != NULL; s = s->next)
4048     {
4049       if ((s->flags & SEC_LOAD) != 0
4050           && strncmp (s->name, ".note", 5) == 0)
4051         {
4052           /* We need a PT_NOTE segment.  */
4053           ++segs;
4054         }
4055     }
4056
4057   for (s = abfd->sections; s != NULL; s = s->next)
4058     {
4059       if (s->flags & SEC_THREAD_LOCAL)
4060         {
4061           /* We need a PT_TLS segment.  */
4062           ++segs;
4063           break;
4064         }
4065     }
4066
4067   /* Let the backend count up any program headers it might need.  */
4068   if (bed->elf_backend_additional_program_headers)
4069     {
4070       int a;
4071
4072       a = (*bed->elf_backend_additional_program_headers) (abfd);
4073       if (a == -1)
4074         abort ();
4075       segs += a;
4076     }
4077
4078   elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4079   return elf_tdata (abfd)->program_header_size;
4080 }
4081
4082 /* Work out the file positions of all the sections.  This is called by
4083    _bfd_elf_compute_section_file_positions.  All the section sizes and
4084    VMAs must be known before this is called.
4085
4086    We do not consider reloc sections at this point, unless they form
4087    part of the loadable image.  Reloc sections are assigned file
4088    positions in assign_file_positions_for_relocs, which is called by
4089    write_object_contents and final_link.
4090
4091    We also don't set the positions of the .symtab and .strtab here.  */
4092
4093 static boolean
4094 assign_file_positions_except_relocs (abfd)
4095      bfd *abfd;
4096 {
4097   struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4098   Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4099   Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4100   unsigned int num_sec = elf_numsections (abfd);
4101   file_ptr off;
4102   struct elf_backend_data *bed = get_elf_backend_data (abfd);
4103
4104   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4105       && bfd_get_format (abfd) != bfd_core)
4106     {
4107       Elf_Internal_Shdr **hdrpp;
4108       unsigned int i;
4109
4110       /* Start after the ELF header.  */
4111       off = i_ehdrp->e_ehsize;
4112
4113       /* We are not creating an executable, which means that we are
4114          not creating a program header, and that the actual order of
4115          the sections in the file is unimportant.  */
4116       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4117         {
4118           Elf_Internal_Shdr *hdr;
4119
4120           hdr = *hdrpp;
4121           if (hdr->sh_type == SHT_REL
4122               || hdr->sh_type == SHT_RELA
4123               || i == tdata->symtab_section
4124               || i == tdata->symtab_shndx_section
4125               || i == tdata->strtab_section)
4126             {
4127               hdr->sh_offset = -1;
4128             }
4129           else
4130             off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
4131
4132           if (i == SHN_LORESERVE - 1)
4133             {
4134               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4135               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4136             }
4137         }
4138     }
4139   else
4140     {
4141       unsigned int i;
4142       Elf_Internal_Shdr **hdrpp;
4143
4144       /* Assign file positions for the loaded sections based on the
4145          assignment of sections to segments.  */
4146       if (! assign_file_positions_for_segments (abfd))
4147         return false;
4148
4149       /* Assign file positions for the other sections.  */
4150
4151       off = elf_tdata (abfd)->next_file_pos;
4152       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4153         {
4154           Elf_Internal_Shdr *hdr;
4155
4156           hdr = *hdrpp;
4157           if (hdr->bfd_section != NULL
4158               && hdr->bfd_section->filepos != 0)
4159             hdr->sh_offset = hdr->bfd_section->filepos;
4160           else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4161             {
4162               ((*_bfd_error_handler)
4163                (_("%s: warning: allocated section `%s' not in segment"),
4164                 bfd_get_filename (abfd),
4165                 (hdr->bfd_section == NULL
4166                  ? "*unknown*"
4167                  : hdr->bfd_section->name)));
4168               if ((abfd->flags & D_PAGED) != 0)
4169                 off += (hdr->sh_addr - off) % bed->maxpagesize;
4170               else
4171                 off += (hdr->sh_addr - off) % hdr->sh_addralign;
4172               off = _bfd_elf_assign_file_position_for_section (hdr, off,
4173                                                                false);
4174             }
4175           else if (hdr->sh_type == SHT_REL
4176                    || hdr->sh_type == SHT_RELA
4177                    || hdr == i_shdrpp[tdata->symtab_section]
4178                    || hdr == i_shdrpp[tdata->symtab_shndx_section]
4179                    || hdr == i_shdrpp[tdata->strtab_section])
4180             hdr->sh_offset = -1;
4181           else
4182             off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
4183
4184           if (i == SHN_LORESERVE - 1)
4185             {
4186               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4187               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4188             }
4189         }
4190     }
4191
4192   /* Place the section headers.  */
4193   off = align_file_position (off, bed->s->file_align);
4194   i_ehdrp->e_shoff = off;
4195   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4196
4197   elf_tdata (abfd)->next_file_pos = off;
4198
4199   return true;
4200 }
4201
4202 static boolean
4203 prep_headers (abfd)
4204      bfd *abfd;
4205 {
4206   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
4207   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4208   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
4209   struct elf_strtab_hash *shstrtab;
4210   struct elf_backend_data *bed = get_elf_backend_data (abfd);
4211
4212   i_ehdrp = elf_elfheader (abfd);
4213   i_shdrp = elf_elfsections (abfd);
4214
4215   shstrtab = _bfd_elf_strtab_init ();
4216   if (shstrtab == NULL)
4217     return false;
4218
4219   elf_shstrtab (abfd) = shstrtab;
4220
4221   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4222   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4223   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4224   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4225
4226   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4227   i_ehdrp->e_ident[EI_DATA] =
4228     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4229   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4230
4231   if ((abfd->flags & DYNAMIC) != 0)
4232     i_ehdrp->e_type = ET_DYN;
4233   else if ((abfd->flags & EXEC_P) != 0)
4234     i_ehdrp->e_type = ET_EXEC;
4235   else if (bfd_get_format (abfd) == bfd_core)
4236     i_ehdrp->e_type = ET_CORE;
4237   else
4238     i_ehdrp->e_type = ET_REL;
4239
4240   switch (bfd_get_arch (abfd))
4241     {
4242     case bfd_arch_unknown:
4243       i_ehdrp->e_machine = EM_NONE;
4244       break;
4245
4246       /* There used to be a long list of cases here, each one setting
4247          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4248          in the corresponding bfd definition.  To avoid duplication,
4249          the switch was removed.  Machines that need special handling
4250          can generally do it in elf_backend_final_write_processing(),
4251          unless they need the information earlier than the final write.
4252          Such need can generally be supplied by replacing the tests for
4253          e_machine with the conditions used to determine it.  */
4254     default:
4255       if (get_elf_backend_data (abfd) != NULL)
4256         i_ehdrp->e_machine = get_elf_backend_data (abfd)->elf_machine_code;
4257       else
4258         i_ehdrp->e_machine = EM_NONE;
4259       }
4260
4261   i_ehdrp->e_version = bed->s->ev_current;
4262   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4263
4264   /* No program header, for now.  */
4265   i_ehdrp->e_phoff = 0;
4266   i_ehdrp->e_phentsize = 0;
4267   i_ehdrp->e_phnum = 0;
4268
4269   /* Each bfd section is section header entry.  */
4270   i_ehdrp->e_entry = bfd_get_start_address (abfd);
4271   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4272
4273   /* If we're building an executable, we'll need a program header table.  */
4274   if (abfd->flags & EXEC_P)
4275     {
4276       /* It all happens later.  */
4277 #if 0
4278       i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
4279
4280       /* elf_build_phdrs() returns a (NULL-terminated) array of
4281          Elf_Internal_Phdrs.  */
4282       i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
4283       i_ehdrp->e_phoff = outbase;
4284       outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
4285 #endif
4286     }
4287   else
4288     {
4289       i_ehdrp->e_phentsize = 0;
4290       i_phdrp = 0;
4291       i_ehdrp->e_phoff = 0;
4292     }
4293
4294   elf_tdata (abfd)->symtab_hdr.sh_name =
4295     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", false);
4296   elf_tdata (abfd)->strtab_hdr.sh_name =
4297     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", false);
4298   elf_tdata (abfd)->shstrtab_hdr.sh_name =
4299     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", false);
4300   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4301       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4302       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4303     return false;
4304
4305   return true;
4306 }
4307
4308 /* Assign file positions for all the reloc sections which are not part
4309    of the loadable file image.  */
4310
4311 void
4312 _bfd_elf_assign_file_positions_for_relocs (abfd)
4313      bfd *abfd;
4314 {
4315   file_ptr off;
4316   unsigned int i, num_sec;
4317   Elf_Internal_Shdr **shdrpp;
4318
4319   off = elf_tdata (abfd)->next_file_pos;
4320
4321   num_sec = elf_numsections (abfd);
4322   for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4323     {
4324       Elf_Internal_Shdr *shdrp;
4325
4326       shdrp = *shdrpp;
4327       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4328           && shdrp->sh_offset == -1)
4329         off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
4330     }
4331
4332   elf_tdata (abfd)->next_file_pos = off;
4333 }
4334
4335 boolean
4336 _bfd_elf_write_object_contents (abfd)
4337      bfd *abfd;
4338 {
4339   struct elf_backend_data *bed = get_elf_backend_data (abfd);
4340   Elf_Internal_Ehdr *i_ehdrp;
4341   Elf_Internal_Shdr **i_shdrp;
4342   boolean failed;
4343   unsigned int count, num_sec;
4344
4345   if (! abfd->output_has_begun
4346       && ! _bfd_elf_compute_section_file_positions
4347              (abfd, (struct bfd_link_info *) NULL))
4348     return false;
4349
4350   i_shdrp = elf_elfsections (abfd);
4351   i_ehdrp = elf_elfheader (abfd);
4352
4353   failed = false;
4354   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4355   if (failed)
4356     return false;
4357
4358   _bfd_elf_assign_file_positions_for_relocs (abfd);
4359
4360   /* After writing the headers, we need to write the sections too...  */
4361   num_sec = elf_numsections (abfd);
4362   for (count = 1; count < num_sec; count++)
4363     {
4364       if (bed->elf_backend_section_processing)
4365         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4366       if (i_shdrp[count]->contents)
4367         {
4368           bfd_size_type amt = i_shdrp[count]->sh_size;
4369
4370           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4371               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4372             return false;
4373         }
4374       if (count == SHN_LORESERVE - 1)
4375         count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4376     }
4377
4378   /* Write out the section header names.  */
4379   if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4380       || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
4381     return false;
4382
4383   if (bed->elf_backend_final_write_processing)
4384     (*bed->elf_backend_final_write_processing) (abfd,
4385                                                 elf_tdata (abfd)->linker);
4386
4387   return bed->s->write_shdrs_and_ehdr (abfd);
4388 }
4389
4390 boolean
4391 _bfd_elf_write_corefile_contents (abfd)
4392      bfd *abfd;
4393 {
4394   /* Hopefully this can be done just like an object file.  */
4395   return _bfd_elf_write_object_contents (abfd);
4396 }
4397
4398 /* Given a section, search the header to find them.  */
4399
4400 int
4401 _bfd_elf_section_from_bfd_section (abfd, asect)
4402      bfd *abfd;
4403      struct sec *asect;
4404 {
4405   struct elf_backend_data *bed;
4406   int index;
4407
4408   if (elf_section_data (asect) != NULL
4409       && elf_section_data (asect)->this_idx != 0)
4410     return elf_section_data (asect)->this_idx;
4411
4412   if (bfd_is_abs_section (asect))
4413     index = SHN_ABS;
4414   else if (bfd_is_com_section (asect))
4415     index = SHN_COMMON;
4416   else if (bfd_is_und_section (asect))
4417     index = SHN_UNDEF;
4418   else
4419     {
4420       Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
4421       int maxindex = elf_numsections (abfd);
4422
4423       for (index = 1; index < maxindex; index++)
4424         {
4425           Elf_Internal_Shdr *hdr = i_shdrp[index];
4426
4427           if (hdr != NULL && hdr->bfd_section == asect)
4428             return index;
4429         }
4430       index = -1;
4431     }
4432
4433   bed = get_elf_backend_data (abfd);
4434   if (bed->elf_backend_section_from_bfd_section)
4435     {
4436       int retval = index;
4437
4438       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4439         return retval;
4440     }
4441
4442   if (index == -1)
4443     bfd_set_error (bfd_error_nonrepresentable_section);
4444
4445   return index;
4446 }
4447
4448 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4449    on error.  */
4450
4451 int
4452 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
4453      bfd *abfd;
4454      asymbol **asym_ptr_ptr;
4455 {
4456   asymbol *asym_ptr = *asym_ptr_ptr;
4457   int idx;
4458   flagword flags = asym_ptr->flags;
4459
4460   /* When gas creates relocations against local labels, it creates its
4461      own symbol for the section, but does put the symbol into the
4462      symbol chain, so udata is 0.  When the linker is generating
4463      relocatable output, this section symbol may be for one of the
4464      input sections rather than the output section.  */
4465   if (asym_ptr->udata.i == 0
4466       && (flags & BSF_SECTION_SYM)
4467       && asym_ptr->section)
4468     {
4469       int indx;
4470
4471       if (asym_ptr->section->output_section != NULL)
4472         indx = asym_ptr->section->output_section->index;
4473       else
4474         indx = asym_ptr->section->index;
4475       if (indx < elf_num_section_syms (abfd)
4476           && elf_section_syms (abfd)[indx] != NULL)
4477         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4478     }
4479
4480   idx = asym_ptr->udata.i;
4481
4482   if (idx == 0)
4483     {
4484       /* This case can occur when using --strip-symbol on a symbol
4485          which is used in a relocation entry.  */
4486       (*_bfd_error_handler)
4487         (_("%s: symbol `%s' required but not present"),
4488          bfd_archive_filename (abfd), bfd_asymbol_name (asym_ptr));
4489       bfd_set_error (bfd_error_no_symbols);
4490       return -1;
4491     }
4492
4493 #if DEBUG & 4
4494   {
4495     fprintf (stderr,
4496              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4497              (long) asym_ptr, asym_ptr->name, idx, flags,
4498              elf_symbol_flags (flags));
4499     fflush (stderr);
4500   }
4501 #endif
4502
4503   return idx;
4504 }
4505
4506 /* Copy private BFD data.  This copies any program header information.  */
4507
4508 static boolean
4509 copy_private_bfd_data (ibfd, obfd)
4510      bfd *ibfd;
4511      bfd *obfd;
4512 {
4513   Elf_Internal_Ehdr *       iehdr;
4514   struct elf_segment_map *  map;
4515   struct elf_segment_map *  map_first;
4516   struct elf_segment_map ** pointer_to_map;
4517   Elf_Internal_Phdr *       segment;
4518   asection *                section;
4519   unsigned int              i;
4520   unsigned int              num_segments;
4521   boolean                   phdr_included = false;
4522   bfd_vma                   maxpagesize;
4523   struct elf_segment_map *  phdr_adjust_seg = NULL;
4524   unsigned int              phdr_adjust_num = 0;
4525   struct elf_backend_data * bed;
4526
4527   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4528       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4529     return true;
4530
4531   if (elf_tdata (ibfd)->phdr == NULL)
4532     return true;
4533
4534   bed = get_elf_backend_data (ibfd);
4535   iehdr = elf_elfheader (ibfd);
4536
4537   map_first = NULL;
4538   pointer_to_map = &map_first;
4539
4540   num_segments = elf_elfheader (ibfd)->e_phnum;
4541   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4542
4543   /* Returns the end address of the segment + 1.  */
4544 #define SEGMENT_END(segment, start)                                     \
4545   (start + (segment->p_memsz > segment->p_filesz                        \
4546             ? segment->p_memsz : segment->p_filesz))
4547
4548   /* Returns true if the given section is contained within
4549      the given segment.  VMA addresses are compared.  */
4550 #define IS_CONTAINED_BY_VMA(section, segment)                           \
4551   (section->vma >= segment->p_vaddr                                     \
4552    && (section->vma + section->_raw_size                                \
4553        <= (SEGMENT_END (segment, segment->p_vaddr))))
4554
4555   /* Returns true if the given section is contained within
4556      the given segment.  LMA addresses are compared.  */
4557 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
4558   (section->lma >= base                                                 \
4559    && (section->lma + section->_raw_size                                \
4560        <= SEGMENT_END (segment, base)))
4561
4562   /* Returns true if the given section is contained within the
4563      given segment.  Filepos addresses are compared in an elf
4564      backend function. */
4565 #define IS_CONTAINED_BY_FILEPOS(sec, seg, bed)                          \
4566   (bed->is_contained_by_filepos                                         \
4567    && (*bed->is_contained_by_filepos) (sec, seg))
4568
4569   /* Special case: corefile "NOTE" section containing regs, prpsinfo etc.  */
4570 #define IS_COREFILE_NOTE(p, s)                                          \
4571   (p->p_type == PT_NOTE                                                 \
4572    && bfd_get_format (ibfd) == bfd_core                                 \
4573    && s->vma == 0 && s->lma == 0                                        \
4574    && (bfd_vma) s->filepos >= p->p_offset                               \
4575    && ((bfd_vma) s->filepos + s->_raw_size                              \
4576        <= p->p_offset + p->p_filesz))
4577
4578   /* The complicated case when p_vaddr is 0 is to handle the Solaris
4579      linker, which generates a PT_INTERP section with p_vaddr and
4580      p_memsz set to 0.  */
4581 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
4582   (p->p_vaddr == 0                                                      \
4583    && p->p_paddr == 0                                                   \
4584    && p->p_memsz == 0                                                   \
4585    && p->p_filesz > 0                                                   \
4586    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
4587    && s->_raw_size > 0                                                  \
4588    && (bfd_vma) s->filepos >= p->p_offset                               \
4589    && ((bfd_vma) s->filepos + s->_raw_size                              \
4590        <= p->p_offset + p->p_filesz))
4591
4592   /* Decide if the given section should be included in the given segment.
4593      A section will be included if:
4594        1. It is within the address space of the segment -- we use the LMA
4595           if that is set for the segment and the VMA otherwise,
4596        2. It is an allocated segment,
4597        3. There is an output section associated with it,
4598        4. The section has not already been allocated to a previous segment.  */
4599 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
4600   ((((segment->p_paddr                                                  \
4601       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
4602       : IS_CONTAINED_BY_VMA (section, segment))                         \
4603      && (section->flags & SEC_ALLOC) != 0)                              \
4604     || IS_COREFILE_NOTE (segment, section)                              \
4605     || (IS_CONTAINED_BY_FILEPOS (section, segment, bed)                 \
4606         && (section->flags & SEC_ALLOC) == 0))                          \
4607    && section->output_section != NULL                                   \
4608    && ! section->segment_mark)
4609
4610   /* Returns true iff seg1 starts after the end of seg2.  */
4611 #define SEGMENT_AFTER_SEGMENT(seg1, seg2)                               \
4612   (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
4613
4614   /* Returns true iff seg1 and seg2 overlap.  */
4615 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
4616   (!(SEGMENT_AFTER_SEGMENT (seg1, seg2)                                 \
4617      || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
4618
4619   /* Initialise the segment mark field.  */
4620   for (section = ibfd->sections; section != NULL; section = section->next)
4621     section->segment_mark = false;
4622
4623   /* Scan through the segments specified in the program header
4624      of the input BFD.  For this first scan we look for overlaps
4625      in the loadable segments.  These can be created by weird
4626      parameters to objcopy.  Also, fix some solaris weirdness.  */
4627   for (i = 0, segment = elf_tdata (ibfd)->phdr;
4628        i < num_segments;
4629        i++, segment++)
4630     {
4631       unsigned int j;
4632       Elf_Internal_Phdr *segment2;
4633
4634       if (segment->p_type == PT_INTERP)
4635         for (section = ibfd->sections; section; section = section->next)
4636           if (IS_SOLARIS_PT_INTERP (segment, section))
4637             {
4638               /* Mininal change so that the normal section to segment
4639                  assigment code will work.  */
4640               segment->p_vaddr = section->vma;
4641               break;
4642             }
4643
4644       if (segment->p_type != PT_LOAD)
4645         continue;
4646
4647       /* Determine if this segment overlaps any previous segments.  */
4648       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
4649         {
4650           bfd_signed_vma extra_length;
4651
4652           if (segment2->p_type != PT_LOAD
4653               || ! SEGMENT_OVERLAPS (segment, segment2))
4654             continue;
4655
4656           /* Merge the two segments together.  */
4657           if (segment2->p_vaddr < segment->p_vaddr)
4658             {
4659               /* Extend SEGMENT2 to include SEGMENT and then delete
4660                  SEGMENT.  */
4661               extra_length =
4662                 SEGMENT_END (segment, segment->p_vaddr)
4663                 - SEGMENT_END (segment2, segment2->p_vaddr);
4664
4665               if (extra_length > 0)
4666                 {
4667                   segment2->p_memsz  += extra_length;
4668                   segment2->p_filesz += extra_length;
4669                 }
4670
4671               segment->p_type = PT_NULL;
4672
4673               /* Since we have deleted P we must restart the outer loop.  */
4674               i = 0;
4675               segment = elf_tdata (ibfd)->phdr;
4676               break;
4677             }
4678           else
4679             {
4680               /* Extend SEGMENT to include SEGMENT2 and then delete
4681                  SEGMENT2.  */
4682               extra_length =
4683                 SEGMENT_END (segment2, segment2->p_vaddr)
4684                 - SEGMENT_END (segment, segment->p_vaddr);
4685
4686               if (extra_length > 0)
4687                 {
4688                   segment->p_memsz  += extra_length;
4689                   segment->p_filesz += extra_length;
4690                 }
4691
4692               segment2->p_type = PT_NULL;
4693             }
4694         }
4695     }
4696
4697   /* The second scan attempts to assign sections to segments.  */
4698   for (i = 0, segment = elf_tdata (ibfd)->phdr;
4699        i < num_segments;
4700        i ++, segment ++)
4701     {
4702       unsigned int  section_count;
4703       asection **   sections;
4704       asection *    output_section;
4705       unsigned int  isec;
4706       bfd_vma       matching_lma;
4707       bfd_vma       suggested_lma;
4708       unsigned int  j;
4709       bfd_size_type amt;
4710
4711       if (segment->p_type == PT_NULL)
4712         continue;
4713
4714       /* Compute how many sections might be placed into this segment.  */
4715       section_count = 0;
4716       for (section = ibfd->sections; section != NULL; section = section->next)
4717         if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
4718           ++section_count;
4719
4720       /* Allocate a segment map big enough to contain all of the
4721          sections we have selected.  */
4722       amt = sizeof (struct elf_segment_map);
4723       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4724       map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
4725       if (map == NULL)
4726         return false;
4727
4728       /* Initialise the fields of the segment map.  Default to
4729          using the physical address of the segment in the input BFD.  */
4730       map->next          = NULL;
4731       map->p_type        = segment->p_type;
4732       map->p_flags       = segment->p_flags;
4733       map->p_flags_valid = 1;
4734       map->p_paddr       = segment->p_paddr;
4735       map->p_paddr_valid = 1;
4736
4737       /* Determine if this segment contains the ELF file header
4738          and if it contains the program headers themselves.  */
4739       map->includes_filehdr = (segment->p_offset == 0
4740                                && segment->p_filesz >= iehdr->e_ehsize);
4741
4742       map->includes_phdrs = 0;
4743
4744       if (! phdr_included || segment->p_type != PT_LOAD)
4745         {
4746           map->includes_phdrs =
4747             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
4748              && (segment->p_offset + segment->p_filesz
4749                  >= ((bfd_vma) iehdr->e_phoff
4750                      + iehdr->e_phnum * iehdr->e_phentsize)));
4751
4752           if (segment->p_type == PT_LOAD && map->includes_phdrs)
4753             phdr_included = true;
4754         }
4755
4756       if (section_count == 0)
4757         {
4758           /* Special segments, such as the PT_PHDR segment, may contain
4759              no sections, but ordinary, loadable segments should contain
4760              something.  They are allowed by the ELF spec however, so only
4761              a warning is produced.  */
4762           if (segment->p_type == PT_LOAD)
4763             (*_bfd_error_handler)
4764               (_("%s: warning: Empty loadable segment detected, is this intentional ?\n"),
4765                bfd_archive_filename (ibfd));
4766
4767           map->count = 0;
4768           *pointer_to_map = map;
4769           pointer_to_map = &map->next;
4770
4771           continue;
4772         }
4773
4774       /* Now scan the sections in the input BFD again and attempt
4775          to add their corresponding output sections to the segment map.
4776          The problem here is how to handle an output section which has
4777          been moved (ie had its LMA changed).  There are four possibilities:
4778
4779          1. None of the sections have been moved.
4780             In this case we can continue to use the segment LMA from the
4781             input BFD.
4782
4783          2. All of the sections have been moved by the same amount.
4784             In this case we can change the segment's LMA to match the LMA
4785             of the first section.
4786
4787          3. Some of the sections have been moved, others have not.
4788             In this case those sections which have not been moved can be
4789             placed in the current segment which will have to have its size,
4790             and possibly its LMA changed, and a new segment or segments will
4791             have to be created to contain the other sections.
4792
4793          4. The sections have been moved, but not be the same amount.
4794             In this case we can change the segment's LMA to match the LMA
4795             of the first section and we will have to create a new segment
4796             or segments to contain the other sections.
4797
4798          In order to save time, we allocate an array to hold the section
4799          pointers that we are interested in.  As these sections get assigned
4800          to a segment, they are removed from this array.  */
4801
4802       /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
4803          to work around this long long bug.  */
4804       amt = section_count * sizeof (asection *);
4805       sections = (asection **) bfd_malloc (amt);
4806       if (sections == NULL)
4807         return false;
4808
4809       /* Step One: Scan for segment vs section LMA conflicts.
4810          Also add the sections to the section array allocated above.
4811          Also add the sections to the current segment.  In the common
4812          case, where the sections have not been moved, this means that
4813          we have completely filled the segment, and there is nothing
4814          more to do.  */
4815       isec = 0;
4816       matching_lma = 0;
4817       suggested_lma = 0;
4818
4819       for (j = 0, section = ibfd->sections;
4820            section != NULL;
4821            section = section->next)
4822         {
4823           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
4824             {
4825               output_section = section->output_section;
4826
4827               sections[j ++] = section;
4828
4829               /* The Solaris native linker always sets p_paddr to 0.
4830                  We try to catch that case here, and set it to the
4831                  correct value.  Note - some backends require that
4832                  p_paddr be left as zero.  */
4833               if (segment->p_paddr == 0
4834                   && segment->p_vaddr != 0
4835                   && (! bed->want_p_paddr_set_to_zero)
4836                   && isec == 0
4837                   && output_section->lma != 0
4838                   && (output_section->vma == (segment->p_vaddr
4839                                               + (map->includes_filehdr
4840                                                  ? iehdr->e_ehsize
4841                                                  : 0)
4842                                               + (map->includes_phdrs
4843                                                  ? (iehdr->e_phnum
4844                                                     * iehdr->e_phentsize)
4845                                                  : 0))))
4846                 map->p_paddr = segment->p_vaddr;
4847
4848               /* Match up the physical address of the segment with the
4849                  LMA address of the output section.  */
4850               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4851                   || IS_CONTAINED_BY_FILEPOS (section, segment, bed)
4852                   || IS_COREFILE_NOTE (segment, section)
4853                   || (bed->want_p_paddr_set_to_zero &&
4854                       IS_CONTAINED_BY_VMA (output_section, segment))
4855                 )
4856                 {
4857                   if (matching_lma == 0)
4858                     matching_lma = output_section->lma;
4859
4860                   /* We assume that if the section fits within the segment
4861                      then it does not overlap any other section within that
4862                      segment.  */
4863                   map->sections[isec ++] = output_section;
4864                 }
4865               else if (suggested_lma == 0)
4866                 suggested_lma = output_section->lma;
4867             }
4868         }
4869
4870       BFD_ASSERT (j == section_count);
4871
4872       /* Step Two: Adjust the physical address of the current segment,
4873          if necessary.  */
4874       if (isec == section_count)
4875         {
4876           /* All of the sections fitted within the segment as currently
4877              specified.  This is the default case.  Add the segment to
4878              the list of built segments and carry on to process the next
4879              program header in the input BFD.  */
4880           map->count = section_count;
4881           *pointer_to_map = map;
4882           pointer_to_map = &map->next;
4883
4884           free (sections);
4885           continue;
4886         }
4887       else
4888         {
4889           if (matching_lma != 0)
4890             {
4891               /* At least one section fits inside the current segment.
4892                  Keep it, but modify its physical address to match the
4893                  LMA of the first section that fitted.  */
4894               map->p_paddr = matching_lma;
4895             }
4896           else
4897             {
4898               /* None of the sections fitted inside the current segment.
4899                  Change the current segment's physical address to match
4900                  the LMA of the first section.  */
4901               map->p_paddr = suggested_lma;
4902             }
4903
4904           /* Offset the segment physical address from the lma
4905              to allow for space taken up by elf headers.  */
4906           if (map->includes_filehdr)
4907             map->p_paddr -= iehdr->e_ehsize;
4908
4909           if (map->includes_phdrs)
4910             {
4911               map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
4912
4913               /* iehdr->e_phnum is just an estimate of the number
4914                  of program headers that we will need.  Make a note
4915                  here of the number we used and the segment we chose
4916                  to hold these headers, so that we can adjust the
4917                  offset when we know the correct value.  */
4918               phdr_adjust_num = iehdr->e_phnum;
4919               phdr_adjust_seg = map;
4920             }
4921         }
4922
4923       /* Step Three: Loop over the sections again, this time assigning
4924          those that fit to the current segment and removing them from the
4925          sections array; but making sure not to leave large gaps.  Once all
4926          possible sections have been assigned to the current segment it is
4927          added to the list of built segments and if sections still remain
4928          to be assigned, a new segment is constructed before repeating
4929          the loop.  */
4930       isec = 0;
4931       do
4932         {
4933           map->count = 0;
4934           suggested_lma = 0;
4935
4936           /* Fill the current segment with sections that fit.  */
4937           for (j = 0; j < section_count; j++)
4938             {
4939               section = sections[j];
4940
4941               if (section == NULL)
4942                 continue;
4943
4944               output_section = section->output_section;
4945
4946               BFD_ASSERT (output_section != NULL);
4947
4948               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4949                   || IS_COREFILE_NOTE (segment, section))
4950                 {
4951                   if (map->count == 0)
4952                     {
4953                       /* If the first section in a segment does not start at
4954                          the beginning of the segment, then something is
4955                          wrong.  */
4956                       if (output_section->lma !=
4957                           (map->p_paddr
4958                            + (map->includes_filehdr ? iehdr->e_ehsize : 0)
4959                            + (map->includes_phdrs
4960                               ? iehdr->e_phnum * iehdr->e_phentsize
4961                               : 0)))
4962                         abort ();
4963                     }
4964                   else
4965                     {
4966                       asection * prev_sec;
4967
4968                       prev_sec = map->sections[map->count - 1];
4969
4970                       /* If the gap between the end of the previous section
4971                          and the start of this section is more than
4972                          maxpagesize then we need to start a new segment.  */
4973                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size,
4974                                       maxpagesize)
4975                            < BFD_ALIGN (output_section->lma, maxpagesize))
4976                           || ((prev_sec->lma + prev_sec->_raw_size)
4977                               > output_section->lma))
4978                         {
4979                           if (suggested_lma == 0)
4980                             suggested_lma = output_section->lma;
4981
4982                           continue;
4983                         }
4984                     }
4985
4986                   map->sections[map->count++] = output_section;
4987                   ++isec;
4988                   sections[j] = NULL;
4989                   section->segment_mark = true;
4990                 }
4991               else if (suggested_lma == 0)
4992                 suggested_lma = output_section->lma;
4993             }
4994
4995           BFD_ASSERT (map->count > 0);
4996
4997           /* Add the current segment to the list of built segments.  */
4998           *pointer_to_map = map;
4999           pointer_to_map = &map->next;
5000
5001           if (isec < section_count)
5002             {
5003               /* We still have not allocated all of the sections to
5004                  segments.  Create a new segment here, initialise it
5005                  and carry on looping.  */
5006               amt = sizeof (struct elf_segment_map);
5007               amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5008               map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
5009               if (map == NULL)
5010                 return false;
5011
5012               /* Initialise the fields of the segment map.  Set the physical
5013                  physical address to the LMA of the first section that has
5014                  not yet been assigned.  */
5015               map->next             = NULL;
5016               map->p_type           = segment->p_type;
5017               map->p_flags          = segment->p_flags;
5018               map->p_flags_valid    = 1;
5019               map->p_paddr          = suggested_lma;
5020               map->p_paddr_valid    = 1;
5021               map->includes_filehdr = 0;
5022               map->includes_phdrs   = 0;
5023             }
5024         }
5025       while (isec < section_count);
5026
5027       free (sections);
5028     }
5029
5030   /* The Solaris linker creates program headers in which all the
5031      p_paddr fields are zero.  When we try to objcopy or strip such a
5032      file, we get confused.  Check for this case, and if we find it
5033      reset the p_paddr_valid fields.  */
5034   for (map = map_first; map != NULL; map = map->next)
5035     if (map->p_paddr != 0)
5036       break;
5037   if (map == NULL)
5038     {
5039       for (map = map_first; map != NULL; map = map->next)
5040         map->p_paddr_valid = 0;
5041     }
5042
5043   elf_tdata (obfd)->segment_map = map_first;
5044
5045   /* If we had to estimate the number of program headers that were
5046      going to be needed, then check our estimate now and adjust
5047      the offset if necessary.  */
5048   if (phdr_adjust_seg != NULL)
5049     {
5050       unsigned int count;
5051
5052       for (count = 0, map = map_first; map != NULL; map = map->next)
5053         count++;
5054
5055       if (count > phdr_adjust_num)
5056         phdr_adjust_seg->p_paddr
5057           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5058     }
5059
5060 #if 0
5061   /* Final Step: Sort the segments into ascending order of physical
5062      address.  */
5063   if (map_first != NULL)
5064     {
5065       struct elf_segment_map *prev;
5066
5067       prev = map_first;
5068       for (map = map_first->next; map != NULL; prev = map, map = map->next)
5069         {
5070           /* Yes I know - its a bubble sort....  */
5071           if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
5072             {
5073               /* Swap map and map->next.  */
5074               prev->next = map->next;
5075               map->next = map->next->next;
5076               prev->next->next = map;
5077
5078               /* Restart loop.  */
5079               map = map_first;
5080             }
5081         }
5082     }
5083 #endif
5084
5085 #undef SEGMENT_END
5086 #undef IS_CONTAINED_BY_VMA
5087 #undef IS_CONTAINED_BY_LMA
5088 #undef IS_CONTAINED_BY_FILEPOS
5089 #undef IS_COREFILE_NOTE
5090 #undef IS_SOLARIS_PT_INTERP
5091 #undef INCLUDE_SECTION_IN_SEGMENT
5092 #undef SEGMENT_AFTER_SEGMENT
5093 #undef SEGMENT_OVERLAPS
5094   return true;
5095 }
5096
5097 /* Copy private section information.  This copies over the entsize
5098    field, and sometimes the info field.  */
5099
5100 boolean
5101 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
5102      bfd *ibfd;
5103      asection *isec;
5104      bfd *obfd;
5105      asection *osec;
5106 {
5107   Elf_Internal_Shdr *ihdr, *ohdr;
5108   const struct elf_backend_data *bed = get_elf_backend_data (ibfd);
5109
5110   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5111       || obfd->xvec->flavour != bfd_target_elf_flavour)
5112     return true;
5113
5114   /* Copy over private BFD data if it has not already been copied.
5115      This must be done here, rather than in the copy_private_bfd_data
5116      entry point, because the latter is called after the section
5117      contents have been set, which means that the program headers have
5118      already been worked out.  The backend function provides a way to
5119      override the test conditions and code path for the call to
5120      copy_private_bfd_data.  */
5121   if (bed->copy_private_bfd_data_p)
5122     {
5123       if ((*bed->copy_private_bfd_data_p) (ibfd, isec, obfd, osec))
5124         if (! copy_private_bfd_data (ibfd, obfd))
5125           return false;
5126     }
5127   else if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5128     {
5129         asection *s;
5130
5131         /* Only set up the segments if there are no more SEC_ALLOC
5132            sections.  FIXME: This won't do the right thing if objcopy is
5133            used to remove the last SEC_ALLOC section, since objcopy
5134            won't call this routine in that case.  */
5135         for (s = isec->next; s != NULL; s = s->next)
5136           if ((s->flags & SEC_ALLOC) != 0)
5137             break;
5138         if (s == NULL)
5139           {
5140             if (! copy_private_bfd_data (ibfd, obfd))
5141               return false;
5142           }
5143     }
5144
5145   ihdr = &elf_section_data (isec)->this_hdr;
5146   ohdr = &elf_section_data (osec)->this_hdr;
5147
5148   ohdr->sh_entsize = ihdr->sh_entsize;
5149
5150   if (ihdr->sh_type == SHT_SYMTAB
5151       || ihdr->sh_type == SHT_DYNSYM
5152       || ihdr->sh_type == SHT_GNU_verneed
5153       || ihdr->sh_type == SHT_GNU_verdef)
5154     ohdr->sh_info = ihdr->sh_info;
5155
5156   /* Set things up for objcopy.  The output SHT_GROUP section will
5157      have its elf_next_in_group pointing back to the input group
5158      members.  */
5159   elf_next_in_group (osec) = elf_next_in_group (isec);
5160   elf_group_name (osec) = elf_group_name (isec);
5161
5162   elf_section_data (osec)->use_rela_p
5163     = elf_section_data (isec)->use_rela_p;
5164
5165   return true;
5166 }
5167
5168 /* Copy private symbol information.  If this symbol is in a section
5169    which we did not map into a BFD section, try to map the section
5170    index correctly.  We use special macro definitions for the mapped
5171    section indices; these definitions are interpreted by the
5172    swap_out_syms function.  */
5173
5174 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5175 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5176 #define MAP_STRTAB    (SHN_HIOS + 3)
5177 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
5178 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5179
5180 boolean
5181 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
5182      bfd *ibfd;
5183      asymbol *isymarg;
5184      bfd *obfd;
5185      asymbol *osymarg;
5186 {
5187   elf_symbol_type *isym, *osym;
5188
5189   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5190       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5191     return true;
5192
5193   isym = elf_symbol_from (ibfd, isymarg);
5194   osym = elf_symbol_from (obfd, osymarg);
5195
5196   if (isym != NULL
5197       && osym != NULL
5198       && bfd_is_abs_section (isym->symbol.section))
5199     {
5200       unsigned int shndx;
5201
5202       shndx = isym->internal_elf_sym.st_shndx;
5203       if (shndx == elf_onesymtab (ibfd))
5204         shndx = MAP_ONESYMTAB;
5205       else if (shndx == elf_dynsymtab (ibfd))
5206         shndx = MAP_DYNSYMTAB;
5207       else if (shndx == elf_tdata (ibfd)->strtab_section)
5208         shndx = MAP_STRTAB;
5209       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5210         shndx = MAP_SHSTRTAB;
5211       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5212         shndx = MAP_SYM_SHNDX;
5213       osym->internal_elf_sym.st_shndx = shndx;
5214     }
5215
5216   return true;
5217 }
5218
5219 /* Swap out the symbols.  */
5220
5221 static boolean
5222 swap_out_syms (abfd, sttp, relocatable_p)
5223      bfd *abfd;
5224      struct bfd_strtab_hash **sttp;
5225      int relocatable_p;
5226 {
5227   struct elf_backend_data *bed;
5228   int symcount;
5229   asymbol **syms;
5230   struct bfd_strtab_hash *stt;
5231   Elf_Internal_Shdr *symtab_hdr;
5232   Elf_Internal_Shdr *symtab_shndx_hdr;
5233   Elf_Internal_Shdr *symstrtab_hdr;
5234   char *outbound_syms;
5235   char *outbound_shndx;
5236   int idx;
5237   bfd_size_type amt;
5238
5239   if (!elf_map_symbols (abfd))
5240     return false;
5241
5242   /* Dump out the symtabs.  */
5243   stt = _bfd_elf_stringtab_init ();
5244   if (stt == NULL)
5245     return false;
5246
5247   bed = get_elf_backend_data (abfd);
5248   symcount = bfd_get_symcount (abfd);
5249   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5250   symtab_hdr->sh_type = SHT_SYMTAB;
5251   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5252   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5253   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5254   symtab_hdr->sh_addralign = bed->s->file_align;
5255
5256   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5257   symstrtab_hdr->sh_type = SHT_STRTAB;
5258
5259   amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
5260   outbound_syms = bfd_alloc (abfd, amt);
5261   if (outbound_syms == NULL)
5262     return false;
5263   symtab_hdr->contents = (PTR) outbound_syms;
5264
5265   outbound_shndx = NULL;
5266   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5267   if (symtab_shndx_hdr->sh_name != 0)
5268     {
5269       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5270       outbound_shndx = bfd_zalloc (abfd, amt);
5271       if (outbound_shndx == NULL)
5272         return false;
5273       symtab_shndx_hdr->contents = outbound_shndx;
5274       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5275       symtab_shndx_hdr->sh_size = amt;
5276       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5277       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5278     }
5279
5280   /* now generate the data (for "contents") */
5281   {
5282     /* Fill in zeroth symbol and swap it out.  */
5283     Elf_Internal_Sym sym;
5284     sym.st_name = 0;
5285     sym.st_value = 0;
5286     sym.st_size = 0;
5287     sym.st_info = 0;
5288     sym.st_other = 0;
5289     sym.st_shndx = SHN_UNDEF;
5290     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5291     outbound_syms += bed->s->sizeof_sym;
5292     if (outbound_shndx != NULL)
5293       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5294   }
5295
5296   syms = bfd_get_outsymbols (abfd);
5297   for (idx = 0; idx < symcount; idx++)
5298     {
5299       Elf_Internal_Sym sym;
5300       bfd_vma value = syms[idx]->value;
5301       elf_symbol_type *type_ptr;
5302       flagword flags = syms[idx]->flags;
5303       int type;
5304
5305       if ((flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5306         {
5307           /* Local section symbols have no name.  */
5308           sym.st_name = 0;
5309         }
5310       else
5311         {
5312           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5313                                                             syms[idx]->name,
5314                                                             true, false);
5315           if (sym.st_name == (unsigned long) -1)
5316             return false;
5317         }
5318
5319       type_ptr = elf_symbol_from (abfd, syms[idx]);
5320
5321       if ((flags & BSF_SECTION_SYM) == 0
5322           && bfd_is_com_section (syms[idx]->section))
5323         {
5324           /* ELF common symbols put the alignment into the `value' field,
5325              and the size into the `size' field.  This is backwards from
5326              how BFD handles it, so reverse it here.  */
5327           sym.st_size = value;
5328           if (type_ptr == NULL
5329               || type_ptr->internal_elf_sym.st_value == 0)
5330             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5331           else
5332             sym.st_value = type_ptr->internal_elf_sym.st_value;
5333           sym.st_shndx = _bfd_elf_section_from_bfd_section
5334             (abfd, syms[idx]->section);
5335         }
5336       else
5337         {
5338           asection *sec = syms[idx]->section;
5339           int shndx;
5340
5341           if (sec->output_section)
5342             {
5343               value += sec->output_offset;
5344               sec = sec->output_section;
5345             }
5346           /* Don't add in the section vma for relocatable output.  */
5347           if (! relocatable_p)
5348             value += sec->vma;
5349           sym.st_value = value;
5350           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5351
5352           if (bfd_is_abs_section (sec)
5353               && type_ptr != NULL
5354               && type_ptr->internal_elf_sym.st_shndx != 0)
5355             {
5356               /* This symbol is in a real ELF section which we did
5357                  not create as a BFD section.  Undo the mapping done
5358                  by copy_private_symbol_data.  */
5359               shndx = type_ptr->internal_elf_sym.st_shndx;
5360               switch (shndx)
5361                 {
5362                 case MAP_ONESYMTAB:
5363                   shndx = elf_onesymtab (abfd);
5364                   break;
5365                 case MAP_DYNSYMTAB:
5366                   shndx = elf_dynsymtab (abfd);
5367                   break;
5368                 case MAP_STRTAB:
5369                   shndx = elf_tdata (abfd)->strtab_section;
5370                   break;
5371                 case MAP_SHSTRTAB:
5372                   shndx = elf_tdata (abfd)->shstrtab_section;
5373                   break;
5374                 case MAP_SYM_SHNDX:
5375                   shndx = elf_tdata (abfd)->symtab_shndx_section;
5376                   break;
5377                 default:
5378                   break;
5379                 }
5380             }
5381           else
5382             {
5383               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5384
5385               if (shndx == -1)
5386                 {
5387                   asection *sec2;
5388
5389                   /* Writing this would be a hell of a lot easier if
5390                      we had some decent documentation on bfd, and
5391                      knew what to expect of the library, and what to
5392                      demand of applications.  For example, it
5393                      appears that `objcopy' might not set the
5394                      section of a symbol to be a section that is
5395                      actually in the output file.  */
5396                   sec2 = bfd_get_section_by_name (abfd, sec->name);
5397                   BFD_ASSERT (sec2 != 0);
5398                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5399                   BFD_ASSERT (shndx != -1);
5400                 }
5401             }
5402
5403           sym.st_shndx = shndx;
5404         }
5405
5406       if ((flags & BSF_THREAD_LOCAL) != 0)
5407         type = STT_TLS;
5408       else if ((flags & BSF_FUNCTION) != 0)
5409         type = STT_FUNC;
5410       else if ((flags & BSF_OBJECT) != 0)
5411         type = STT_OBJECT;
5412       else
5413         type = STT_NOTYPE;
5414
5415       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
5416         type = STT_TLS;
5417
5418       /* Processor-specific types */
5419       if (type_ptr != NULL
5420           && bed->elf_backend_get_symbol_type)
5421         type = ((*bed->elf_backend_get_symbol_type)
5422                 (&type_ptr->internal_elf_sym, type));
5423
5424       if (flags & BSF_SECTION_SYM)
5425         {
5426           if (flags & BSF_GLOBAL)
5427             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5428           else
5429             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5430         }
5431       else if (bfd_is_com_section (syms[idx]->section))
5432         sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5433       else if (bfd_is_und_section (syms[idx]->section))
5434         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5435                                     ? STB_WEAK
5436                                     : STB_GLOBAL),
5437                                    type);
5438       else if (flags & BSF_FILE)
5439         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5440       else
5441         {
5442           int bind = STB_LOCAL;
5443
5444           if (flags & BSF_LOCAL)
5445             bind = STB_LOCAL;
5446           else if (flags & BSF_WEAK)
5447             bind = STB_WEAK;
5448           else if (flags & BSF_GLOBAL)
5449             bind = STB_GLOBAL;
5450
5451           sym.st_info = ELF_ST_INFO (bind, type);
5452         }
5453
5454       if (type_ptr != NULL)
5455         sym.st_other = type_ptr->internal_elf_sym.st_other;
5456       else
5457         sym.st_other = 0;
5458
5459       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5460       outbound_syms += bed->s->sizeof_sym;
5461       if (outbound_shndx != NULL)
5462         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5463     }
5464
5465   *sttp = stt;
5466   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
5467   symstrtab_hdr->sh_type = SHT_STRTAB;
5468
5469   symstrtab_hdr->sh_flags = 0;
5470   symstrtab_hdr->sh_addr = 0;
5471   symstrtab_hdr->sh_entsize = 0;
5472   symstrtab_hdr->sh_link = 0;
5473   symstrtab_hdr->sh_info = 0;
5474   symstrtab_hdr->sh_addralign = 1;
5475
5476   return true;
5477 }
5478
5479 /* Return the number of bytes required to hold the symtab vector.
5480
5481    Note that we base it on the count plus 1, since we will null terminate
5482    the vector allocated based on this size.  However, the ELF symbol table
5483    always has a dummy entry as symbol #0, so it ends up even.  */
5484
5485 long
5486 _bfd_elf_get_symtab_upper_bound (abfd)
5487      bfd *abfd;
5488 {
5489   long symcount;
5490   long symtab_size;
5491   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
5492
5493   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5494   symtab_size = (symcount + 1) * (sizeof (asymbol *));
5495   if (symcount > 0)
5496     symtab_size -= sizeof (asymbol *);
5497
5498   return symtab_size;
5499 }
5500
5501 long
5502 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
5503      bfd *abfd;
5504 {
5505   long symcount;
5506   long symtab_size;
5507   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
5508
5509   if (elf_dynsymtab (abfd) == 0)
5510     {
5511       bfd_set_error (bfd_error_invalid_operation);
5512       return -1;
5513     }
5514
5515   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5516   symtab_size = (symcount + 1) * (sizeof (asymbol *));
5517   if (symcount > 0)
5518     symtab_size -= sizeof (asymbol *);
5519
5520   return symtab_size;
5521 }
5522
5523 long
5524 _bfd_elf_get_reloc_upper_bound (abfd, asect)
5525      bfd *abfd ATTRIBUTE_UNUSED;
5526      sec_ptr asect;
5527 {
5528   return (asect->reloc_count + 1) * sizeof (arelent *);
5529 }
5530
5531 /* Canonicalize the relocs.  */
5532
5533 long
5534 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
5535      bfd *abfd;
5536      sec_ptr section;
5537      arelent **relptr;
5538      asymbol **symbols;
5539 {
5540   arelent *tblptr;
5541   unsigned int i;
5542   struct elf_backend_data *bed = get_elf_backend_data (abfd);
5543
5544   if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
5545     return -1;
5546
5547   tblptr = section->relocation;
5548   for (i = 0; i < section->reloc_count; i++)
5549     *relptr++ = tblptr++;
5550
5551   *relptr = NULL;
5552
5553   return section->reloc_count;
5554 }
5555
5556 long
5557 _bfd_elf_get_symtab (abfd, alocation)
5558      bfd *abfd;
5559      asymbol **alocation;
5560 {
5561   struct elf_backend_data *bed = get_elf_backend_data (abfd);
5562   long symcount = bed->s->slurp_symbol_table (abfd, alocation, false);
5563
5564   if (symcount >= 0)
5565     bfd_get_symcount (abfd) = symcount;
5566   return symcount;
5567 }
5568
5569 long
5570 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
5571      bfd *abfd;
5572      asymbol **alocation;
5573 {
5574   struct elf_backend_data *bed = get_elf_backend_data (abfd);
5575   return bed->s->slurp_symbol_table (abfd, alocation, true);
5576 }
5577
5578 /* Return the size required for the dynamic reloc entries.  Any
5579    section that was actually installed in the BFD, and has type
5580    SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5581    considered to be a dynamic reloc section.  */
5582
5583 long
5584 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
5585      bfd *abfd;
5586 {
5587   long ret;
5588   asection *s;
5589
5590   if (elf_dynsymtab (abfd) == 0)
5591     {
5592       bfd_set_error (bfd_error_invalid_operation);
5593       return -1;
5594     }
5595
5596   ret = sizeof (arelent *);
5597   for (s = abfd->sections; s != NULL; s = s->next)
5598     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5599         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5600             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5601       ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
5602               * sizeof (arelent *));
5603
5604   return ret;
5605 }
5606
5607 /* Canonicalize the dynamic relocation entries.  Note that we return
5608    the dynamic relocations as a single block, although they are
5609    actually associated with particular sections; the interface, which
5610    was designed for SunOS style shared libraries, expects that there
5611    is only one set of dynamic relocs.  Any section that was actually
5612    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5613    the dynamic symbol table, is considered to be a dynamic reloc
5614    section.  */
5615
5616 long
5617 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
5618      bfd *abfd;
5619      arelent **storage;
5620      asymbol **syms;
5621 {
5622   boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
5623   asection *s;
5624   long ret;
5625
5626   if (elf_dynsymtab (abfd) == 0)
5627     {
5628       bfd_set_error (bfd_error_invalid_operation);
5629       return -1;
5630     }
5631
5632   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5633   ret = 0;
5634   for (s = abfd->sections; s != NULL; s = s->next)
5635     {
5636       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5637           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5638               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5639         {
5640           arelent *p;
5641           long count, i;
5642
5643           if (! (*slurp_relocs) (abfd, s, syms, true))
5644             return -1;
5645           count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
5646           p = s->relocation;
5647           for (i = 0; i < count; i++)
5648             *storage++ = p++;
5649           ret += count;
5650         }
5651     }
5652
5653   *storage = NULL;
5654
5655   return ret;
5656 }
5657 \f
5658 /* Read in the version information.  */
5659
5660 boolean
5661 _bfd_elf_slurp_version_tables (abfd)
5662      bfd *abfd;
5663 {
5664   bfd_byte *contents = NULL;
5665   bfd_size_type amt;
5666
5667   if (elf_dynverdef (abfd) != 0)
5668     {
5669       Elf_Internal_Shdr *hdr;
5670       Elf_External_Verdef *everdef;
5671       Elf_Internal_Verdef *iverdef;
5672       Elf_Internal_Verdef *iverdefarr;
5673       Elf_Internal_Verdef iverdefmem;
5674       unsigned int i;
5675       unsigned int maxidx;
5676
5677       hdr = &elf_tdata (abfd)->dynverdef_hdr;
5678
5679       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5680       if (contents == NULL)
5681         goto error_return;
5682       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5683           || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5684         goto error_return;
5685
5686       /* We know the number of entries in the section but not the maximum
5687          index.  Therefore we have to run through all entries and find
5688          the maximum.  */
5689       everdef = (Elf_External_Verdef *) contents;
5690       maxidx = 0;
5691       for (i = 0; i < hdr->sh_info; ++i)
5692         {
5693           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5694
5695           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
5696             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
5697
5698           everdef = ((Elf_External_Verdef *)
5699                      ((bfd_byte *) everdef + iverdefmem.vd_next));
5700         }
5701
5702       amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
5703       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) bfd_zalloc (abfd, amt);
5704       if (elf_tdata (abfd)->verdef == NULL)
5705         goto error_return;
5706
5707       elf_tdata (abfd)->cverdefs = maxidx;
5708
5709       everdef = (Elf_External_Verdef *) contents;
5710       iverdefarr = elf_tdata (abfd)->verdef;
5711       for (i = 0; i < hdr->sh_info; i++)
5712         {
5713           Elf_External_Verdaux *everdaux;
5714           Elf_Internal_Verdaux *iverdaux;
5715           unsigned int j;
5716
5717           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5718
5719           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
5720           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
5721
5722           iverdef->vd_bfd = abfd;
5723
5724           amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
5725           iverdef->vd_auxptr = (Elf_Internal_Verdaux *) bfd_alloc (abfd, amt);
5726           if (iverdef->vd_auxptr == NULL)
5727             goto error_return;
5728
5729           everdaux = ((Elf_External_Verdaux *)
5730                       ((bfd_byte *) everdef + iverdef->vd_aux));
5731           iverdaux = iverdef->vd_auxptr;
5732           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
5733             {
5734               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
5735
5736               iverdaux->vda_nodename =
5737                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5738                                                  iverdaux->vda_name);
5739               if (iverdaux->vda_nodename == NULL)
5740                 goto error_return;
5741
5742               if (j + 1 < iverdef->vd_cnt)
5743                 iverdaux->vda_nextptr = iverdaux + 1;
5744               else
5745                 iverdaux->vda_nextptr = NULL;
5746
5747               everdaux = ((Elf_External_Verdaux *)
5748                           ((bfd_byte *) everdaux + iverdaux->vda_next));
5749             }
5750
5751           iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
5752
5753           if (i + 1 < hdr->sh_info)
5754             iverdef->vd_nextdef = iverdef + 1;
5755           else
5756             iverdef->vd_nextdef = NULL;
5757
5758           everdef = ((Elf_External_Verdef *)
5759                      ((bfd_byte *) everdef + iverdef->vd_next));
5760         }
5761
5762       free (contents);
5763       contents = NULL;
5764     }
5765
5766   if (elf_dynverref (abfd) != 0)
5767     {
5768       Elf_Internal_Shdr *hdr;
5769       Elf_External_Verneed *everneed;
5770       Elf_Internal_Verneed *iverneed;
5771       unsigned int i;
5772
5773       hdr = &elf_tdata (abfd)->dynverref_hdr;
5774
5775       amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
5776       elf_tdata (abfd)->verref =
5777         (Elf_Internal_Verneed *) bfd_zalloc (abfd, amt);
5778       if (elf_tdata (abfd)->verref == NULL)
5779         goto error_return;
5780
5781       elf_tdata (abfd)->cverrefs = hdr->sh_info;
5782
5783       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5784       if (contents == NULL)
5785         goto error_return;
5786       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5787           || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5788         goto error_return;
5789
5790       everneed = (Elf_External_Verneed *) contents;
5791       iverneed = elf_tdata (abfd)->verref;
5792       for (i = 0; i < hdr->sh_info; i++, iverneed++)
5793         {
5794           Elf_External_Vernaux *evernaux;
5795           Elf_Internal_Vernaux *ivernaux;
5796           unsigned int j;
5797
5798           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
5799
5800           iverneed->vn_bfd = abfd;
5801
5802           iverneed->vn_filename =
5803             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5804                                              iverneed->vn_file);
5805           if (iverneed->vn_filename == NULL)
5806             goto error_return;
5807
5808           amt = iverneed->vn_cnt;
5809           amt *= sizeof (Elf_Internal_Vernaux);
5810           iverneed->vn_auxptr = (Elf_Internal_Vernaux *) bfd_alloc (abfd, amt);
5811
5812           evernaux = ((Elf_External_Vernaux *)
5813                       ((bfd_byte *) everneed + iverneed->vn_aux));
5814           ivernaux = iverneed->vn_auxptr;
5815           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
5816             {
5817               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
5818
5819               ivernaux->vna_nodename =
5820                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5821                                                  ivernaux->vna_name);
5822               if (ivernaux->vna_nodename == NULL)
5823                 goto error_return;
5824
5825               if (j + 1 < iverneed->vn_cnt)
5826                 ivernaux->vna_nextptr = ivernaux + 1;
5827               else
5828                 ivernaux->vna_nextptr = NULL;
5829
5830               evernaux = ((Elf_External_Vernaux *)
5831                           ((bfd_byte *) evernaux + ivernaux->vna_next));
5832             }
5833
5834           if (i + 1 < hdr->sh_info)
5835             iverneed->vn_nextref = iverneed + 1;
5836           else
5837             iverneed->vn_nextref = NULL;
5838
5839           everneed = ((Elf_External_Verneed *)
5840                       ((bfd_byte *) everneed + iverneed->vn_next));
5841         }
5842
5843       free (contents);
5844       contents = NULL;
5845     }
5846
5847   return true;
5848
5849  error_return:
5850   if (contents == NULL)
5851     free (contents);
5852   return false;
5853 }
5854 \f
5855 asymbol *
5856 _bfd_elf_make_empty_symbol (abfd)
5857      bfd *abfd;
5858 {
5859   elf_symbol_type *newsym;
5860   bfd_size_type amt = sizeof (elf_symbol_type);
5861
5862   newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
5863   if (!newsym)
5864     return NULL;
5865   else
5866     {
5867       newsym->symbol.the_bfd = abfd;
5868       return &newsym->symbol;
5869     }
5870 }
5871
5872 void
5873 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
5874      bfd *ignore_abfd ATTRIBUTE_UNUSED;
5875      asymbol *symbol;
5876      symbol_info *ret;
5877 {
5878   bfd_symbol_info (symbol, ret);
5879 }
5880
5881 /* Return whether a symbol name implies a local symbol.  Most targets
5882    use this function for the is_local_label_name entry point, but some
5883    override it.  */
5884
5885 boolean
5886 _bfd_elf_is_local_label_name (abfd, name)
5887      bfd *abfd ATTRIBUTE_UNUSED;
5888      const char *name;
5889 {
5890   /* Normal local symbols start with ``.L''.  */
5891   if (name[0] == '.' && name[1] == 'L')
5892     return true;
5893
5894   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5895      DWARF debugging symbols starting with ``..''.  */
5896   if (name[0] == '.' && name[1] == '.')
5897     return true;
5898
5899   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5900      emitting DWARF debugging output.  I suspect this is actually a
5901      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5902      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5903      underscore to be emitted on some ELF targets).  For ease of use,
5904      we treat such symbols as local.  */
5905   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
5906     return true;
5907
5908   return false;
5909 }
5910
5911 alent *
5912 _bfd_elf_get_lineno (ignore_abfd, symbol)
5913      bfd *ignore_abfd ATTRIBUTE_UNUSED;
5914      asymbol *symbol ATTRIBUTE_UNUSED;
5915 {
5916   abort ();
5917   return NULL;
5918 }
5919
5920 boolean
5921 _bfd_elf_set_arch_mach (abfd, arch, machine)
5922      bfd *abfd;
5923      enum bfd_architecture arch;
5924      unsigned long machine;
5925 {
5926   /* If this isn't the right architecture for this backend, and this
5927      isn't the generic backend, fail.  */
5928   if (arch != get_elf_backend_data (abfd)->arch
5929       && arch != bfd_arch_unknown
5930       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
5931     return false;
5932
5933   return bfd_default_set_arch_mach (abfd, arch, machine);
5934 }
5935
5936 /* Find the function to a particular section and offset,
5937    for error reporting.  */
5938
5939 static boolean
5940 elf_find_function (abfd, section, symbols, offset,
5941                    filename_ptr, functionname_ptr)
5942      bfd *abfd ATTRIBUTE_UNUSED;
5943      asection *section;
5944      asymbol **symbols;
5945      bfd_vma offset;
5946      const char **filename_ptr;
5947      const char **functionname_ptr;
5948 {
5949   const char *filename;
5950   asymbol *func;
5951   bfd_vma low_func;
5952   asymbol **p;
5953
5954   filename = NULL;
5955   func = NULL;
5956   low_func = 0;
5957
5958   for (p = symbols; *p != NULL; p++)
5959     {
5960       elf_symbol_type *q;
5961
5962       q = (elf_symbol_type *) *p;
5963
5964       if (bfd_get_section (&q->symbol) != section)
5965         continue;
5966
5967       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5968         {
5969         default:
5970           break;
5971         case STT_FILE:
5972           filename = bfd_asymbol_name (&q->symbol);
5973           break;
5974         case STT_NOTYPE:
5975         case STT_FUNC:
5976           if (q->symbol.section == section
5977               && q->symbol.value >= low_func
5978               && q->symbol.value <= offset)
5979             {
5980               func = (asymbol *) q;
5981               low_func = q->symbol.value;
5982             }
5983           break;
5984         }
5985     }
5986
5987   if (func == NULL)
5988     return false;
5989
5990   if (filename_ptr)
5991     *filename_ptr = filename;
5992   if (functionname_ptr)
5993     *functionname_ptr = bfd_asymbol_name (func);
5994
5995   return true;
5996 }
5997
5998 /* Find the nearest line to a particular section and offset,
5999    for error reporting.  */
6000
6001 boolean
6002 _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
6003                             filename_ptr, functionname_ptr, line_ptr)
6004      bfd *abfd;
6005      asection *section;
6006      asymbol **symbols;
6007      bfd_vma offset;
6008      const char **filename_ptr;
6009      const char **functionname_ptr;
6010      unsigned int *line_ptr;
6011 {
6012   boolean found;
6013
6014   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6015                                      filename_ptr, functionname_ptr,
6016                                      line_ptr))
6017     {
6018       if (!*functionname_ptr)
6019         elf_find_function (abfd, section, symbols, offset,
6020                            *filename_ptr ? NULL : filename_ptr,
6021                            functionname_ptr);
6022
6023       return true;
6024     }
6025
6026   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6027                                      filename_ptr, functionname_ptr,
6028                                      line_ptr, 0,
6029                                      &elf_tdata (abfd)->dwarf2_find_line_info))
6030     {
6031       if (!*functionname_ptr)
6032         elf_find_function (abfd, section, symbols, offset,
6033                            *filename_ptr ? NULL : filename_ptr,
6034                            functionname_ptr);
6035
6036       return true;
6037     }
6038
6039   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6040                                              &found, filename_ptr,
6041                                              functionname_ptr, line_ptr,
6042                                              &elf_tdata (abfd)->line_info))
6043     return false;
6044   if (found)
6045     return true;
6046
6047   if (symbols == NULL)
6048     return false;
6049
6050   if (! elf_find_function (abfd, section, symbols, offset,
6051                            filename_ptr, functionname_ptr))
6052     return false;
6053
6054   *line_ptr = 0;
6055   return true;
6056 }
6057
6058 int
6059 _bfd_elf_sizeof_headers (abfd, reloc)
6060      bfd *abfd;
6061      boolean reloc;
6062 {
6063   int ret;
6064
6065   ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6066   if (! reloc)
6067     ret += get_program_header_size (abfd);
6068   return ret;
6069 }
6070
6071 boolean
6072 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
6073      bfd *abfd;
6074      sec_ptr section;
6075      PTR location;
6076      file_ptr offset;
6077      bfd_size_type count;
6078 {
6079   Elf_Internal_Shdr *hdr;
6080   bfd_signed_vma pos;
6081
6082   if (! abfd->output_has_begun
6083       && ! (_bfd_elf_compute_section_file_positions
6084             (abfd, (struct bfd_link_info *) NULL)))
6085     return false;
6086
6087   hdr = &elf_section_data (section)->this_hdr;
6088   pos = hdr->sh_offset + offset;
6089   if (bfd_seek (abfd, pos, SEEK_SET) != 0
6090       || bfd_bwrite (location, count, abfd) != count)
6091     return false;
6092
6093   return true;
6094 }
6095
6096 void
6097 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
6098      bfd *abfd ATTRIBUTE_UNUSED;
6099      arelent *cache_ptr ATTRIBUTE_UNUSED;
6100      Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
6101 {
6102   abort ();
6103 }
6104
6105 #if 0
6106 void
6107 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
6108      bfd *abfd;
6109      arelent *cache_ptr;
6110      Elf_Internal_Rel *dst;
6111 {
6112   abort ();
6113 }
6114 #endif
6115
6116 /* Try to convert a non-ELF reloc into an ELF one.  */
6117
6118 boolean
6119 _bfd_elf_validate_reloc (abfd, areloc)
6120      bfd *abfd;
6121      arelent *areloc;
6122 {
6123   /* Check whether we really have an ELF howto.  */
6124
6125   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6126     {
6127       bfd_reloc_code_real_type code;
6128       reloc_howto_type *howto;
6129
6130       /* Alien reloc: Try to determine its type to replace it with an
6131          equivalent ELF reloc.  */
6132
6133       if (areloc->howto->pc_relative)
6134         {
6135           switch (areloc->howto->bitsize)
6136             {
6137             case 8:
6138               code = BFD_RELOC_8_PCREL;
6139               break;
6140             case 12:
6141               code = BFD_RELOC_12_PCREL;
6142               break;
6143             case 16:
6144               code = BFD_RELOC_16_PCREL;
6145               break;
6146             case 24:
6147               code = BFD_RELOC_24_PCREL;
6148               break;
6149             case 32:
6150               code = BFD_RELOC_32_PCREL;
6151               break;
6152             case 64:
6153               code = BFD_RELOC_64_PCREL;
6154               break;
6155             default:
6156               goto fail;
6157             }
6158
6159           howto = bfd_reloc_type_lookup (abfd, code);
6160
6161           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6162             {
6163               if (howto->pcrel_offset)
6164                 areloc->addend += areloc->address;
6165               else
6166                 areloc->addend -= areloc->address; /* addend is unsigned!! */
6167             }
6168         }
6169       else
6170         {
6171           switch (areloc->howto->bitsize)
6172             {
6173             case 8:
6174               code = BFD_RELOC_8;
6175               break;
6176             case 14:
6177               code = BFD_RELOC_14;
6178               break;
6179             case 16:
6180               code = BFD_RELOC_16;
6181               break;
6182             case 26:
6183               code = BFD_RELOC_26;
6184               break;
6185             case 32:
6186               code = BFD_RELOC_32;
6187               break;
6188             case 64:
6189               code = BFD_RELOC_64;
6190               break;
6191             default:
6192               goto fail;
6193             }
6194
6195           howto = bfd_reloc_type_lookup (abfd, code);
6196         }
6197
6198       if (howto)
6199         areloc->howto = howto;
6200       else
6201         goto fail;
6202     }
6203
6204   return true;
6205
6206  fail:
6207   (*_bfd_error_handler)
6208     (_("%s: unsupported relocation type %s"),
6209      bfd_archive_filename (abfd), areloc->howto->name);
6210   bfd_set_error (bfd_error_bad_value);
6211   return false;
6212 }
6213
6214 boolean
6215 _bfd_elf_close_and_cleanup (abfd)
6216      bfd *abfd;
6217 {
6218   if (bfd_get_format (abfd) == bfd_object)
6219     {
6220       if (elf_shstrtab (abfd) != NULL)
6221         _bfd_elf_strtab_free (elf_shstrtab (abfd));
6222     }
6223
6224   return _bfd_generic_close_and_cleanup (abfd);
6225 }
6226
6227 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6228    in the relocation's offset.  Thus we cannot allow any sort of sanity
6229    range-checking to interfere.  There is nothing else to do in processing
6230    this reloc.  */
6231
6232 bfd_reloc_status_type
6233 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
6234      bfd *abfd ATTRIBUTE_UNUSED;
6235      arelent *re ATTRIBUTE_UNUSED;
6236      struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
6237      PTR data ATTRIBUTE_UNUSED;
6238      asection *is ATTRIBUTE_UNUSED;
6239      bfd *obfd ATTRIBUTE_UNUSED;
6240      char **errmsg ATTRIBUTE_UNUSED;
6241 {
6242   return bfd_reloc_ok;
6243 }
6244 \f
6245 /* Elf core file support.  Much of this only works on native
6246    toolchains, since we rely on knowing the
6247    machine-dependent procfs structure in order to pick
6248    out details about the corefile.  */
6249
6250 #ifdef HAVE_SYS_PROCFS_H
6251 # include <sys/procfs.h>
6252 #endif
6253
6254 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
6255
6256 static int
6257 elfcore_make_pid (abfd)
6258      bfd *abfd;
6259 {
6260   return ((elf_tdata (abfd)->core_lwpid << 16)
6261           + (elf_tdata (abfd)->core_pid));
6262 }
6263
6264 /* If there isn't a section called NAME, make one, using
6265    data from SECT.  Note, this function will generate a
6266    reference to NAME, so you shouldn't deallocate or
6267    overwrite it.  */
6268
6269 static boolean
6270 elfcore_maybe_make_sect (abfd, name, sect)
6271      bfd *abfd;
6272      char *name;
6273      asection *sect;
6274 {
6275   asection *sect2;
6276
6277   if (bfd_get_section_by_name (abfd, name) != NULL)
6278     return true;
6279
6280   sect2 = bfd_make_section (abfd, name);
6281   if (sect2 == NULL)
6282     return false;
6283
6284   sect2->_raw_size = sect->_raw_size;
6285   sect2->filepos = sect->filepos;
6286   sect2->flags = sect->flags;
6287   sect2->alignment_power = sect->alignment_power;
6288   return true;
6289 }
6290
6291 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
6292    actually creates up to two pseudosections:
6293    - For the single-threaded case, a section named NAME, unless
6294      such a section already exists.
6295    - For the multi-threaded case, a section named "NAME/PID", where
6296      PID is elfcore_make_pid (abfd).
6297    Both pseudosections have identical contents. */
6298 boolean
6299 _bfd_elfcore_make_pseudosection (abfd, name, size, filepos)
6300      bfd *abfd;
6301      char *name;
6302      size_t size;
6303      ufile_ptr filepos;
6304 {
6305   char buf[100];
6306   char *threaded_name;
6307   size_t len;
6308   asection *sect;
6309
6310   /* Build the section name.  */
6311
6312   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
6313   len = strlen (buf) + 1;
6314   threaded_name = bfd_alloc (abfd, (bfd_size_type) len);
6315   if (threaded_name == NULL)
6316     return false;
6317   memcpy (threaded_name, buf, len);
6318
6319   sect = bfd_make_section (abfd, threaded_name);
6320   if (sect == NULL)
6321     return false;
6322   sect->_raw_size = size;
6323   sect->filepos = filepos;
6324   sect->flags = SEC_HAS_CONTENTS;
6325   sect->alignment_power = 2;
6326
6327   return elfcore_maybe_make_sect (abfd, name, sect);
6328 }
6329
6330 /* prstatus_t exists on:
6331      solaris 2.5+
6332      linux 2.[01] + glibc
6333      unixware 4.2
6334 */
6335
6336 #if defined (HAVE_PRSTATUS_T)
6337 static boolean elfcore_grok_prstatus PARAMS ((bfd *, Elf_Internal_Note *));
6338
6339 static boolean
6340 elfcore_grok_prstatus (abfd, note)
6341      bfd *abfd;
6342      Elf_Internal_Note *note;
6343 {
6344   size_t raw_size;
6345   int offset;
6346
6347   if (note->descsz == sizeof (prstatus_t))
6348     {
6349       prstatus_t prstat;
6350
6351       raw_size = sizeof (prstat.pr_reg);
6352       offset   = offsetof (prstatus_t, pr_reg);
6353       memcpy (&prstat, note->descdata, sizeof (prstat));
6354
6355       /* Do not overwrite the core signal if it
6356          has already been set by another thread.  */
6357       if (elf_tdata (abfd)->core_signal == 0)
6358         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6359       elf_tdata (abfd)->core_pid = prstat.pr_pid;
6360
6361       /* pr_who exists on:
6362          solaris 2.5+
6363          unixware 4.2
6364          pr_who doesn't exist on:
6365          linux 2.[01]
6366          */
6367 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6368       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6369 #endif
6370     }
6371 #if defined (HAVE_PRSTATUS32_T)
6372   else if (note->descsz == sizeof (prstatus32_t))
6373     {
6374       /* 64-bit host, 32-bit corefile */
6375       prstatus32_t prstat;
6376
6377       raw_size = sizeof (prstat.pr_reg);
6378       offset   = offsetof (prstatus32_t, pr_reg);
6379       memcpy (&prstat, note->descdata, sizeof (prstat));
6380
6381       /* Do not overwrite the core signal if it
6382          has already been set by another thread.  */
6383       if (elf_tdata (abfd)->core_signal == 0)
6384         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6385       elf_tdata (abfd)->core_pid = prstat.pr_pid;
6386
6387       /* pr_who exists on:
6388          solaris 2.5+
6389          unixware 4.2
6390          pr_who doesn't exist on:
6391          linux 2.[01]
6392          */
6393 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6394       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6395 #endif
6396     }
6397 #endif /* HAVE_PRSTATUS32_T */
6398   else
6399     {
6400       /* Fail - we don't know how to handle any other
6401          note size (ie. data object type).  */
6402       return true;
6403     }
6404
6405   /* Make a ".reg/999" section and a ".reg" section.  */
6406   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
6407                                           raw_size, note->descpos + offset);
6408 }
6409 #endif /* defined (HAVE_PRSTATUS_T) */
6410
6411 /* Create a pseudosection containing the exact contents of NOTE.  */
6412 static boolean
6413 elfcore_make_note_pseudosection (abfd, name, note)
6414      bfd *abfd;
6415      char *name;
6416      Elf_Internal_Note *note;
6417 {
6418   return _bfd_elfcore_make_pseudosection (abfd, name,
6419                                           note->descsz, note->descpos);
6420 }
6421
6422 /* There isn't a consistent prfpregset_t across platforms,
6423    but it doesn't matter, because we don't have to pick this
6424    data structure apart.  */
6425
6426 static boolean
6427 elfcore_grok_prfpreg (abfd, note)
6428      bfd *abfd;
6429      Elf_Internal_Note *note;
6430 {
6431   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6432 }
6433
6434 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6435    type of 5 (NT_PRXFPREG).  Just include the whole note's contents
6436    literally.  */
6437
6438 static boolean
6439 elfcore_grok_prxfpreg (abfd, note)
6440      bfd *abfd;
6441      Elf_Internal_Note *note;
6442 {
6443   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
6444 }
6445
6446 #if defined (HAVE_PRPSINFO_T)
6447 typedef prpsinfo_t   elfcore_psinfo_t;
6448 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
6449 typedef prpsinfo32_t elfcore_psinfo32_t;
6450 #endif
6451 #endif
6452
6453 #if defined (HAVE_PSINFO_T)
6454 typedef psinfo_t   elfcore_psinfo_t;
6455 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
6456 typedef psinfo32_t elfcore_psinfo32_t;
6457 #endif
6458 #endif
6459
6460 /* return a malloc'ed copy of a string at START which is at
6461    most MAX bytes long, possibly without a terminating '\0'.
6462    the copy will always have a terminating '\0'.  */
6463
6464 char *
6465 _bfd_elfcore_strndup (abfd, start, max)
6466      bfd *abfd;
6467      char *start;
6468      size_t max;
6469 {
6470   char *dups;
6471   char *end = memchr (start, '\0', max);
6472   size_t len;
6473
6474   if (end == NULL)
6475     len = max;
6476   else
6477     len = end - start;
6478
6479   dups = bfd_alloc (abfd, (bfd_size_type) len + 1);
6480   if (dups == NULL)
6481     return NULL;
6482
6483   memcpy (dups, start, len);
6484   dups[len] = '\0';
6485
6486   return dups;
6487 }
6488
6489 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6490 static boolean elfcore_grok_psinfo PARAMS ((bfd *, Elf_Internal_Note *));
6491
6492 static boolean
6493 elfcore_grok_psinfo (abfd, note)
6494      bfd *abfd;
6495      Elf_Internal_Note *note;
6496 {
6497   if (note->descsz == sizeof (elfcore_psinfo_t))
6498     {
6499       elfcore_psinfo_t psinfo;
6500
6501       memcpy (&psinfo, note->descdata, sizeof (psinfo));
6502
6503       elf_tdata (abfd)->core_program
6504         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6505                                 sizeof (psinfo.pr_fname));
6506
6507       elf_tdata (abfd)->core_command
6508         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6509                                 sizeof (psinfo.pr_psargs));
6510     }
6511 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6512   else if (note->descsz == sizeof (elfcore_psinfo32_t))
6513     {
6514       /* 64-bit host, 32-bit corefile */
6515       elfcore_psinfo32_t psinfo;
6516
6517       memcpy (&psinfo, note->descdata, sizeof (psinfo));
6518
6519       elf_tdata (abfd)->core_program
6520         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6521                                 sizeof (psinfo.pr_fname));
6522
6523       elf_tdata (abfd)->core_command
6524         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6525                                 sizeof (psinfo.pr_psargs));
6526     }
6527 #endif
6528
6529   else
6530     {
6531       /* Fail - we don't know how to handle any other
6532          note size (ie. data object type).  */
6533       return true;
6534     }
6535
6536   /* Note that for some reason, a spurious space is tacked
6537      onto the end of the args in some (at least one anyway)
6538      implementations, so strip it off if it exists.  */
6539
6540   {
6541     char *command = elf_tdata (abfd)->core_command;
6542     int n = strlen (command);
6543
6544     if (0 < n && command[n - 1] == ' ')
6545       command[n - 1] = '\0';
6546   }
6547
6548   return true;
6549 }
6550 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6551
6552 #if defined (HAVE_PSTATUS_T)
6553 static boolean elfcore_grok_pstatus PARAMS ((bfd *, Elf_Internal_Note *));
6554
6555 static boolean
6556 elfcore_grok_pstatus (abfd, note)
6557      bfd *abfd;
6558      Elf_Internal_Note *note;
6559 {
6560   if (note->descsz == sizeof (pstatus_t)
6561 #if defined (HAVE_PXSTATUS_T)
6562       || note->descsz == sizeof (pxstatus_t)
6563 #endif
6564       )
6565     {
6566       pstatus_t pstat;
6567
6568       memcpy (&pstat, note->descdata, sizeof (pstat));
6569
6570       elf_tdata (abfd)->core_pid = pstat.pr_pid;
6571     }
6572 #if defined (HAVE_PSTATUS32_T)
6573   else if (note->descsz == sizeof (pstatus32_t))
6574     {
6575       /* 64-bit host, 32-bit corefile */
6576       pstatus32_t pstat;
6577
6578       memcpy (&pstat, note->descdata, sizeof (pstat));
6579
6580       elf_tdata (abfd)->core_pid = pstat.pr_pid;
6581     }
6582 #endif
6583   /* Could grab some more details from the "representative"
6584      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6585      NT_LWPSTATUS note, presumably.  */
6586
6587   return true;
6588 }
6589 #endif /* defined (HAVE_PSTATUS_T) */
6590
6591 #if defined (HAVE_LWPSTATUS_T)
6592 static boolean elfcore_grok_lwpstatus PARAMS ((bfd *, Elf_Internal_Note *));
6593
6594 static boolean
6595 elfcore_grok_lwpstatus (abfd, note)
6596      bfd *abfd;
6597      Elf_Internal_Note *note;
6598 {
6599   lwpstatus_t lwpstat;
6600   char buf[100];
6601   char *name;
6602   size_t len;
6603   asection *sect;
6604
6605   if (note->descsz != sizeof (lwpstat)
6606 #if defined (HAVE_LWPXSTATUS_T)
6607       && note->descsz != sizeof (lwpxstatus_t)
6608 #endif
6609       )
6610     return true;
6611
6612   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
6613
6614   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
6615   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
6616
6617   /* Make a ".reg/999" section.  */
6618
6619   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
6620   len = strlen (buf) + 1;
6621   name = bfd_alloc (abfd, (bfd_size_type) len);
6622   if (name == NULL)
6623     return false;
6624   memcpy (name, buf, len);
6625
6626   sect = bfd_make_section (abfd, name);
6627   if (sect == NULL)
6628     return false;
6629
6630 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6631   sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
6632   sect->filepos = note->descpos
6633     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
6634 #endif
6635
6636 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6637   sect->_raw_size = sizeof (lwpstat.pr_reg);
6638   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
6639 #endif
6640
6641   sect->flags = SEC_HAS_CONTENTS;
6642   sect->alignment_power = 2;
6643
6644   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
6645     return false;
6646
6647   /* Make a ".reg2/999" section */
6648
6649   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
6650   len = strlen (buf) + 1;
6651   name = bfd_alloc (abfd, (bfd_size_type) len);
6652   if (name == NULL)
6653     return false;
6654   memcpy (name, buf, len);
6655
6656   sect = bfd_make_section (abfd, name);
6657   if (sect == NULL)
6658     return false;
6659
6660 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6661   sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
6662   sect->filepos = note->descpos
6663     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
6664 #endif
6665
6666 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6667   sect->_raw_size = sizeof (lwpstat.pr_fpreg);
6668   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
6669 #endif
6670
6671   sect->flags = SEC_HAS_CONTENTS;
6672   sect->alignment_power = 2;
6673
6674   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
6675 }
6676 #endif /* defined (HAVE_LWPSTATUS_T) */
6677
6678 #if defined (HAVE_WIN32_PSTATUS_T)
6679 static boolean
6680 elfcore_grok_win32pstatus (abfd, note)
6681      bfd *abfd;
6682      Elf_Internal_Note *note;
6683 {
6684   char buf[30];
6685   char *name;
6686   size_t len;
6687   asection *sect;
6688   win32_pstatus_t pstatus;
6689
6690   if (note->descsz < sizeof (pstatus))
6691     return true;
6692
6693   memcpy (&pstatus, note->descdata, sizeof (pstatus));
6694
6695   switch (pstatus.data_type)
6696     {
6697     case NOTE_INFO_PROCESS:
6698       /* FIXME: need to add ->core_command.  */
6699       elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
6700       elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
6701       break;
6702
6703     case NOTE_INFO_THREAD:
6704       /* Make a ".reg/999" section.  */
6705       sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
6706
6707       len = strlen (buf) + 1;
6708       name = bfd_alloc (abfd, (bfd_size_type) len);
6709       if (name == NULL)
6710         return false;
6711
6712       memcpy (name, buf, len);
6713
6714       sect = bfd_make_section (abfd, name);
6715       if (sect == NULL)
6716         return false;
6717
6718       sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
6719       sect->filepos = (note->descpos
6720                        + offsetof (struct win32_pstatus,
6721                                    data.thread_info.thread_context));
6722       sect->flags = SEC_HAS_CONTENTS;
6723       sect->alignment_power = 2;
6724
6725       if (pstatus.data.thread_info.is_active_thread)
6726         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
6727           return false;
6728       break;
6729
6730     case NOTE_INFO_MODULE:
6731       /* Make a ".module/xxxxxxxx" section.  */
6732       sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
6733
6734       len = strlen (buf) + 1;
6735       name = bfd_alloc (abfd, (bfd_size_type) len);
6736       if (name == NULL)
6737         return false;
6738
6739       memcpy (name, buf, len);
6740
6741       sect = bfd_make_section (abfd, name);
6742
6743       if (sect == NULL)
6744         return false;
6745
6746       sect->_raw_size = note->descsz;
6747       sect->filepos = note->descpos;
6748       sect->flags = SEC_HAS_CONTENTS;
6749       sect->alignment_power = 2;
6750       break;
6751
6752     default:
6753       return true;
6754     }
6755
6756   return true;
6757 }
6758 #endif /* HAVE_WIN32_PSTATUS_T */
6759
6760 static boolean
6761 elfcore_grok_note (abfd, note)
6762      bfd *abfd;
6763      Elf_Internal_Note *note;
6764 {
6765   struct elf_backend_data *bed = get_elf_backend_data (abfd);
6766
6767   switch (note->type)
6768     {
6769     default:
6770       return true;
6771
6772     case NT_PRSTATUS:
6773       if (bed->elf_backend_grok_prstatus)
6774         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
6775           return true;
6776 #if defined (HAVE_PRSTATUS_T)
6777       return elfcore_grok_prstatus (abfd, note);
6778 #else
6779       return true;
6780 #endif
6781
6782 #if defined (HAVE_PSTATUS_T)
6783     case NT_PSTATUS:
6784       return elfcore_grok_pstatus (abfd, note);
6785 #endif
6786
6787 #if defined (HAVE_LWPSTATUS_T)
6788     case NT_LWPSTATUS:
6789       return elfcore_grok_lwpstatus (abfd, note);
6790 #endif
6791
6792     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
6793       return elfcore_grok_prfpreg (abfd, note);
6794
6795 #if defined (HAVE_WIN32_PSTATUS_T)
6796     case NT_WIN32PSTATUS:
6797       return elfcore_grok_win32pstatus (abfd, note);
6798 #endif
6799
6800     case NT_PRXFPREG:           /* Linux SSE extension */
6801       if (note->namesz == 5
6802           && ! strcmp (note->namedata, "LINUX"))
6803         return elfcore_grok_prxfpreg (abfd, note);
6804       else
6805         return true;
6806
6807     case NT_PRPSINFO:
6808     case NT_PSINFO:
6809       if (bed->elf_backend_grok_psinfo)
6810         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
6811           return true;
6812 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6813       return elfcore_grok_psinfo (abfd, note);
6814 #else
6815       return true;
6816 #endif
6817     }
6818 }
6819
6820 static boolean
6821 elfcore_netbsd_get_lwpid (note, lwpidp)
6822      Elf_Internal_Note *note;
6823      int *lwpidp;
6824 {
6825   char *cp;
6826
6827   cp = strchr (note->namedata, '@');
6828   if (cp != NULL)
6829     {
6830       *lwpidp = atoi(cp + 1);
6831       return true;
6832     }
6833   return false;
6834 }
6835
6836 static boolean
6837 elfcore_grok_netbsd_procinfo (abfd, note)
6838      bfd *abfd;
6839      Elf_Internal_Note *note;
6840 {
6841
6842   /* Signal number at offset 0x08. */
6843   elf_tdata (abfd)->core_signal
6844     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
6845
6846   /* Process ID at offset 0x50. */
6847   elf_tdata (abfd)->core_pid
6848     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
6849
6850   /* Command name at 0x7c (max 32 bytes, including nul). */
6851   elf_tdata (abfd)->core_command
6852     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
6853
6854   return true;
6855 }
6856
6857 static boolean
6858 elfcore_grok_netbsd_note (abfd, note)
6859      bfd *abfd;
6860      Elf_Internal_Note *note;
6861 {
6862   int lwp;
6863
6864   if (elfcore_netbsd_get_lwpid (note, &lwp))
6865     elf_tdata (abfd)->core_lwpid = lwp;
6866
6867   if (note->type == NT_NETBSDCORE_PROCINFO)
6868     {
6869       /* NetBSD-specific core "procinfo".  Note that we expect to
6870          find this note before any of the others, which is fine,
6871          since the kernel writes this note out first when it
6872          creates a core file.  */
6873
6874       return elfcore_grok_netbsd_procinfo (abfd, note);
6875     }
6876
6877   /* As of Jan 2002 there are no other machine-independent notes
6878      defined for NetBSD core files.  If the note type is less
6879      than the start of the machine-dependent note types, we don't
6880      understand it.  */
6881
6882   if (note->type < NT_NETBSDCORE_FIRSTMACH)
6883     return true;
6884
6885
6886   switch (bfd_get_arch (abfd))
6887     {
6888     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6889        PT_GETFPREGS == mach+2.  */
6890
6891     case bfd_arch_alpha:
6892     case bfd_arch_sparc:
6893       switch (note->type)
6894         {
6895         case NT_NETBSDCORE_FIRSTMACH+0:
6896           return elfcore_make_note_pseudosection (abfd, ".reg", note);
6897
6898         case NT_NETBSDCORE_FIRSTMACH+2:
6899           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6900
6901         default:
6902           return true;
6903         }
6904
6905     /* On all other arch's, PT_GETREGS == mach+1 and
6906        PT_GETFPREGS == mach+3.  */
6907
6908     default:
6909       switch (note->type)
6910         {
6911         case NT_NETBSDCORE_FIRSTMACH+1:
6912           return elfcore_make_note_pseudosection (abfd, ".reg", note);
6913
6914         case NT_NETBSDCORE_FIRSTMACH+3:
6915           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6916
6917         default:
6918           return true;
6919         }
6920     }
6921     /* NOTREACHED */
6922 }
6923
6924 /* Function: elfcore_write_note
6925
6926    Inputs:
6927      buffer to hold note
6928      name of note
6929      type of note
6930      data for note
6931      size of data for note
6932
6933    Return:
6934    End of buffer containing note.  */
6935
6936 char *
6937 elfcore_write_note (abfd, buf, bufsiz, name, type, input, size)
6938      bfd  *abfd;
6939      char *buf;
6940      int  *bufsiz;
6941      const char *name;
6942      int  type;
6943      const PTR input;
6944      int  size;
6945 {
6946   Elf_External_Note *xnp;
6947   size_t namesz;
6948   size_t pad;
6949   size_t newspace;
6950   char *p, *dest;
6951
6952   namesz = 0;
6953   pad = 0;
6954   if (name != NULL)
6955     {
6956       struct elf_backend_data *bed;
6957
6958       namesz = strlen (name) + 1;
6959       bed = get_elf_backend_data (abfd);
6960       pad = -namesz & (bed->s->file_align - 1);
6961     }
6962
6963   newspace = sizeof (Elf_External_Note) - 1 + namesz + pad + size;
6964
6965   p = realloc (buf, *bufsiz + newspace);
6966   dest = p + *bufsiz;
6967   *bufsiz += newspace;
6968   xnp = (Elf_External_Note *) dest;
6969   H_PUT_32 (abfd, namesz, xnp->namesz);
6970   H_PUT_32 (abfd, size, xnp->descsz);
6971   H_PUT_32 (abfd, type, xnp->type);
6972   dest = xnp->name;
6973   if (name != NULL)
6974     {
6975       memcpy (dest, name, namesz);
6976       dest += namesz;
6977       while (pad != 0)
6978         {
6979           *dest++ = '\0';
6980           --pad;
6981         }
6982     }
6983   memcpy (dest, input, size);
6984   return p;
6985 }
6986
6987 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6988 char *
6989 elfcore_write_prpsinfo (abfd, buf, bufsiz, fname, psargs)
6990      bfd  *abfd;
6991      char *buf;
6992      int  *bufsiz;
6993      const char *fname;
6994      const char *psargs;
6995 {
6996   int note_type;
6997   char *note_name = "CORE";
6998
6999 #if defined (HAVE_PSINFO_T)
7000   psinfo_t  data;
7001   note_type = NT_PSINFO;
7002 #else
7003   prpsinfo_t data;
7004   note_type = NT_PRPSINFO;
7005 #endif
7006
7007   memset (&data, 0, sizeof (data));
7008   strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7009   strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7010   return elfcore_write_note (abfd, buf, bufsiz,
7011                              note_name, note_type, &data, sizeof (data));
7012 }
7013 #endif  /* PSINFO_T or PRPSINFO_T */
7014
7015 #if defined (HAVE_PRSTATUS_T)
7016 char *
7017 elfcore_write_prstatus (abfd, buf, bufsiz, pid, cursig, gregs)
7018      bfd *abfd;
7019      char *buf;
7020      int *bufsiz;
7021      long pid;
7022      int cursig;
7023      const PTR gregs;
7024 {
7025   prstatus_t prstat;
7026   char *note_name = "CORE";
7027
7028   memset (&prstat, 0, sizeof (prstat));
7029   prstat.pr_pid = pid;
7030   prstat.pr_cursig = cursig;
7031   memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7032   return elfcore_write_note (abfd, buf, bufsiz,
7033                              note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7034 }
7035 #endif /* HAVE_PRSTATUS_T */
7036
7037 #if defined (HAVE_LWPSTATUS_T)
7038 char *
7039 elfcore_write_lwpstatus (abfd, buf, bufsiz, pid, cursig, gregs)
7040      bfd *abfd;
7041      char *buf;
7042      int *bufsiz;
7043      long pid;
7044      int cursig;
7045      const PTR gregs;
7046 {
7047   lwpstatus_t lwpstat;
7048   char *note_name = "CORE";
7049
7050   memset (&lwpstat, 0, sizeof (lwpstat));
7051   lwpstat.pr_lwpid  = pid >> 16;
7052   lwpstat.pr_cursig = cursig;
7053 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7054   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7055 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7056 #if !defined(gregs)
7057   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7058           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7059 #else
7060   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7061           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7062 #endif
7063 #endif
7064   return elfcore_write_note (abfd, buf, bufsiz, note_name,
7065                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7066 }
7067 #endif /* HAVE_LWPSTATUS_T */
7068
7069 #if defined (HAVE_PSTATUS_T)
7070 char *
7071 elfcore_write_pstatus (abfd, buf, bufsiz, pid, cursig, gregs)
7072      bfd *abfd;
7073      char *buf;
7074      int *bufsiz;
7075      long pid;
7076      int cursig;
7077      const PTR gregs;
7078 {
7079   pstatus_t pstat;
7080   char *note_name = "CORE";
7081
7082   memset (&pstat, 0, sizeof (pstat));
7083   pstat.pr_pid = pid & 0xffff;
7084   buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
7085                             NT_PSTATUS, &pstat, sizeof (pstat));
7086   return buf;
7087 }
7088 #endif /* HAVE_PSTATUS_T */
7089
7090 char *
7091 elfcore_write_prfpreg (abfd, buf, bufsiz, fpregs, size)
7092      bfd  *abfd;
7093      char *buf;
7094      int  *bufsiz;
7095      const PTR fpregs;
7096      int size;
7097 {
7098   char *note_name = "CORE";
7099   return elfcore_write_note (abfd, buf, bufsiz,
7100                              note_name, NT_FPREGSET, fpregs, size);
7101 }
7102
7103 char *
7104 elfcore_write_prxfpreg (abfd, buf, bufsiz, xfpregs, size)
7105      bfd  *abfd;
7106      char *buf;
7107      int  *bufsiz;
7108      const PTR xfpregs;
7109      int size;
7110 {
7111   char *note_name = "LINUX";
7112   return elfcore_write_note (abfd, buf, bufsiz,
7113                              note_name, NT_PRXFPREG, xfpregs, size);
7114 }
7115
7116 static boolean
7117 elfcore_read_notes (abfd, offset, size)
7118      bfd *abfd;
7119      file_ptr offset;
7120      bfd_size_type size;
7121 {
7122   char *buf;
7123   char *p;
7124
7125   if (size <= 0)
7126     return true;
7127
7128   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
7129     return false;
7130
7131   buf = bfd_malloc (size);
7132   if (buf == NULL)
7133     return false;
7134
7135   if (bfd_bread (buf, size, abfd) != size)
7136     {
7137     error:
7138       free (buf);
7139       return false;
7140     }
7141
7142   p = buf;
7143   while (p < buf + size)
7144     {
7145       /* FIXME: bad alignment assumption.  */
7146       Elf_External_Note *xnp = (Elf_External_Note *) p;
7147       Elf_Internal_Note in;
7148
7149       in.type = H_GET_32 (abfd, xnp->type);
7150
7151       in.namesz = H_GET_32 (abfd, xnp->namesz);
7152       in.namedata = xnp->name;
7153
7154       in.descsz = H_GET_32 (abfd, xnp->descsz);
7155       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7156       in.descpos = offset + (in.descdata - buf);
7157
7158       if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7159         {
7160           if (! elfcore_grok_netbsd_note (abfd, &in))
7161             goto error;
7162         }
7163       else
7164         {
7165           if (! elfcore_grok_note (abfd, &in))
7166             goto error;
7167         }
7168
7169       p = in.descdata + BFD_ALIGN (in.descsz, 4);
7170     }
7171
7172   free (buf);
7173   return true;
7174 }
7175 \f
7176 /* Providing external access to the ELF program header table.  */
7177
7178 /* Return an upper bound on the number of bytes required to store a
7179    copy of ABFD's program header table entries.  Return -1 if an error
7180    occurs; bfd_get_error will return an appropriate code.  */
7181
7182 long
7183 bfd_get_elf_phdr_upper_bound (abfd)
7184      bfd *abfd;
7185 {
7186   if (abfd->xvec->flavour != bfd_target_elf_flavour)
7187     {
7188       bfd_set_error (bfd_error_wrong_format);
7189       return -1;
7190     }
7191
7192   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
7193 }
7194
7195 /* Copy ABFD's program header table entries to *PHDRS.  The entries
7196    will be stored as an array of Elf_Internal_Phdr structures, as
7197    defined in include/elf/internal.h.  To find out how large the
7198    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7199
7200    Return the number of program header table entries read, or -1 if an
7201    error occurs; bfd_get_error will return an appropriate code.  */
7202
7203 int
7204 bfd_get_elf_phdrs (abfd, phdrs)
7205      bfd *abfd;
7206      void *phdrs;
7207 {
7208   int num_phdrs;
7209
7210   if (abfd->xvec->flavour != bfd_target_elf_flavour)
7211     {
7212       bfd_set_error (bfd_error_wrong_format);
7213       return -1;
7214     }
7215
7216   num_phdrs = elf_elfheader (abfd)->e_phnum;
7217   memcpy (phdrs, elf_tdata (abfd)->phdr,
7218           num_phdrs * sizeof (Elf_Internal_Phdr));
7219
7220   return num_phdrs;
7221 }
7222
7223 void
7224 _bfd_elf_sprintf_vma (abfd, buf, value)
7225      bfd *abfd ATTRIBUTE_UNUSED;
7226      char *buf;
7227      bfd_vma value;
7228 {
7229 #ifdef BFD64
7230   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
7231
7232   i_ehdrp = elf_elfheader (abfd);
7233   if (i_ehdrp == NULL)
7234     sprintf_vma (buf, value);
7235   else
7236     {
7237       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7238         {
7239 #if BFD_HOST_64BIT_LONG
7240           sprintf (buf, "%016lx", value);
7241 #else
7242           sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
7243                    _bfd_int64_low (value));
7244 #endif
7245         }
7246       else
7247         sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
7248     }
7249 #else
7250   sprintf_vma (buf, value);
7251 #endif
7252 }
7253
7254 void
7255 _bfd_elf_fprintf_vma (abfd, stream, value)
7256      bfd *abfd ATTRIBUTE_UNUSED;
7257      PTR stream;
7258      bfd_vma value;
7259 {
7260 #ifdef BFD64
7261   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
7262
7263   i_ehdrp = elf_elfheader (abfd);
7264   if (i_ehdrp == NULL)
7265     fprintf_vma ((FILE *) stream, value);
7266   else
7267     {
7268       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7269         {
7270 #if BFD_HOST_64BIT_LONG
7271           fprintf ((FILE *) stream, "%016lx", value);
7272 #else
7273           fprintf ((FILE *) stream, "%08lx%08lx",
7274                    _bfd_int64_high (value), _bfd_int64_low (value));
7275 #endif
7276         }
7277       else
7278         fprintf ((FILE *) stream, "%08lx",
7279                  (unsigned long) (value & 0xffffffff));
7280     }
7281 #else
7282   fprintf_vma ((FILE *) stream, value);
7283 #endif
7284 }
7285
7286 enum elf_reloc_type_class
7287 _bfd_elf_reloc_type_class (rela)
7288      const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED;
7289 {
7290   return reloc_class_normal;
7291 }
7292
7293 /* For RELA architectures, return the relocation value for a
7294    relocation against a local symbol.  */
7295
7296 bfd_vma
7297 _bfd_elf_rela_local_sym (abfd, sym, sec, rel)
7298      bfd *abfd;
7299      Elf_Internal_Sym *sym;
7300      asection *sec;
7301      Elf_Internal_Rela *rel;
7302 {
7303   bfd_vma relocation;
7304
7305   relocation = (sec->output_section->vma
7306                 + sec->output_offset
7307                 + sym->st_value);
7308   if ((sec->flags & SEC_MERGE)
7309       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
7310       && elf_section_data (sec)->sec_info_type == ELF_INFO_TYPE_MERGE)
7311     {
7312       asection *msec;
7313
7314       msec = sec;
7315       rel->r_addend =
7316         _bfd_merged_section_offset (abfd, &msec,
7317                                     elf_section_data (sec)->sec_info,
7318                                     sym->st_value + rel->r_addend,
7319                                     (bfd_vma) 0)
7320         - relocation;
7321       rel->r_addend += msec->output_section->vma + msec->output_offset;
7322     }
7323   return relocation;
7324 }
7325
7326 bfd_vma
7327 _bfd_elf_rel_local_sym (abfd, sym, psec, addend)
7328      bfd *abfd;
7329      Elf_Internal_Sym *sym;
7330      asection **psec;
7331      bfd_vma addend;
7332 {
7333   asection *sec = *psec;
7334
7335   if (elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_MERGE)
7336     return sym->st_value + addend;
7337
7338   return _bfd_merged_section_offset (abfd, psec,
7339                                      elf_section_data (sec)->sec_info,
7340                                      sym->st_value + addend, (bfd_vma) 0);
7341 }
7342
7343 bfd_vma
7344 _bfd_elf_section_offset (abfd, info, sec, offset)
7345      bfd *abfd;
7346      struct bfd_link_info *info;
7347      asection *sec;
7348      bfd_vma offset;
7349 {
7350   struct bfd_elf_section_data *sec_data;
7351
7352   sec_data = elf_section_data (sec);
7353   switch (sec_data->sec_info_type)
7354     {
7355     case ELF_INFO_TYPE_STABS:
7356       return _bfd_stab_section_offset
7357         (abfd, &elf_hash_table (info)->merge_info, sec, &sec_data->sec_info,
7358          offset);
7359     case ELF_INFO_TYPE_EH_FRAME:
7360       return _bfd_elf_eh_frame_section_offset (abfd, sec, offset);
7361     default:
7362       return offset;
7363     }
7364 }