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