bfd/elf.c

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