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