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 (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 it's 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   sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2246   len = strlen (namebuf) + 1;
2247   name = bfd_alloc (abfd, len);
2248   if (!name)
2249     return FALSE;
2250   memcpy (name, namebuf, len);
2251   newsect = bfd_make_section (abfd, name);
2252   if (newsect == NULL)
2253     return FALSE;
2254   newsect->vma = hdr->p_vaddr;
2255   newsect->lma = hdr->p_paddr;
2256   newsect->size = hdr->p_filesz;
2257   newsect->filepos = hdr->p_offset;
2258   newsect->flags |= SEC_HAS_CONTENTS;
2259   newsect->alignment_power = bfd_log2 (hdr->p_align);
2260   if (hdr->p_type == PT_LOAD)
2261     {
2262       newsect->flags |= SEC_ALLOC;
2263       newsect->flags |= SEC_LOAD;
2264       if (hdr->p_flags & PF_X)
2265         {
2266           /* FIXME: all we known is that it has execute PERMISSION,
2267              may be data.  */
2268           newsect->flags |= SEC_CODE;
2269         }
2270     }
2271   if (!(hdr->p_flags & PF_W))
2272     {
2273       newsect->flags |= SEC_READONLY;
2274     }
2275
2276   if (split)
2277     {
2278       sprintf (namebuf, "%s%db", typename, index);
2279       len = strlen (namebuf) + 1;
2280       name = bfd_alloc (abfd, len);
2281       if (!name)
2282         return FALSE;
2283       memcpy (name, namebuf, len);
2284       newsect = bfd_make_section (abfd, name);
2285       if (newsect == NULL)
2286         return FALSE;
2287       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2288       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2289       newsect->size = hdr->p_memsz - hdr->p_filesz;
2290       if (hdr->p_type == PT_LOAD)
2291         {
2292           newsect->flags |= SEC_ALLOC;
2293           if (hdr->p_flags & PF_X)
2294             newsect->flags |= SEC_CODE;
2295         }
2296       if (!(hdr->p_flags & PF_W))
2297         newsect->flags |= SEC_READONLY;
2298     }
2299
2300   return TRUE;
2301 }
2302
2303 bfd_boolean
2304 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2305 {
2306   const struct elf_backend_data *bed;
2307
2308   switch (hdr->p_type)
2309     {
2310     case PT_NULL:
2311       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2312
2313     case PT_LOAD:
2314       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2315
2316     case PT_DYNAMIC:
2317       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2318
2319     case PT_INTERP:
2320       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2321
2322     case PT_NOTE:
2323       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2324         return FALSE;
2325       if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2326         return FALSE;
2327       return TRUE;
2328
2329     case PT_SHLIB:
2330       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2331
2332     case PT_PHDR:
2333       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2334
2335     case PT_GNU_EH_FRAME:
2336       return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2337                                               "eh_frame_hdr");
2338
2339     case PT_GNU_STACK:
2340       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2341
2342     case PT_GNU_RELRO:
2343       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2344
2345     default:
2346       /* Check for any processor-specific program segment types.  */
2347       bed = get_elf_backend_data (abfd);
2348       return bed->elf_backend_section_from_phdr (abfd, hdr, index, "proc");
2349     }
2350 }
2351
2352 /* Initialize REL_HDR, the section-header for new section, containing
2353    relocations against ASECT.  If USE_RELA_P is TRUE, we use RELA
2354    relocations; otherwise, we use REL relocations.  */
2355
2356 bfd_boolean
2357 _bfd_elf_init_reloc_shdr (bfd *abfd,
2358                           Elf_Internal_Shdr *rel_hdr,
2359                           asection *asect,
2360                           bfd_boolean use_rela_p)
2361 {
2362   char *name;
2363   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2364   bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2365
2366   name = bfd_alloc (abfd, amt);
2367   if (name == NULL)
2368     return FALSE;
2369   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2370   rel_hdr->sh_name =
2371     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2372                                         FALSE);
2373   if (rel_hdr->sh_name == (unsigned int) -1)
2374     return FALSE;
2375   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2376   rel_hdr->sh_entsize = (use_rela_p
2377                          ? bed->s->sizeof_rela
2378                          : bed->s->sizeof_rel);
2379   rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2380   rel_hdr->sh_flags = 0;
2381   rel_hdr->sh_addr = 0;
2382   rel_hdr->sh_size = 0;
2383   rel_hdr->sh_offset = 0;
2384
2385   return TRUE;
2386 }
2387
2388 /* Set up an ELF internal section header for a section.  */
2389
2390 static void
2391 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2392 {
2393   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2394   bfd_boolean *failedptr = failedptrarg;
2395   Elf_Internal_Shdr *this_hdr;
2396   unsigned int sh_type;
2397
2398   if (*failedptr)
2399     {
2400       /* We already failed; just get out of the bfd_map_over_sections
2401          loop.  */
2402       return;
2403     }
2404
2405   this_hdr = &elf_section_data (asect)->this_hdr;
2406
2407   this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2408                                                           asect->name, FALSE);
2409   if (this_hdr->sh_name == (unsigned int) -1)
2410     {
2411       *failedptr = TRUE;
2412       return;
2413     }
2414
2415   /* Don't clear sh_flags. Assembler may set additional bits.  */
2416
2417   if ((asect->flags & SEC_ALLOC) != 0
2418       || asect->user_set_vma)
2419     this_hdr->sh_addr = asect->vma;
2420   else
2421     this_hdr->sh_addr = 0;
2422
2423   this_hdr->sh_offset = 0;
2424   this_hdr->sh_size = asect->size;
2425   this_hdr->sh_link = 0;
2426   this_hdr->sh_addralign = 1 << asect->alignment_power;
2427   /* The sh_entsize and sh_info fields may have been set already by
2428      copy_private_section_data.  */
2429
2430   this_hdr->bfd_section = asect;
2431   this_hdr->contents = NULL;
2432
2433   /* If the section type is unspecified, we set it based on
2434      asect->flags.  */
2435   if (this_hdr->sh_type == SHT_NULL)
2436     {
2437       if ((asect->flags & SEC_GROUP) != 0)
2438         this_hdr->sh_type = SHT_GROUP;
2439       else if ((asect->flags & SEC_ALLOC) != 0
2440                && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2441                    || (asect->flags & SEC_NEVER_LOAD) != 0))
2442         this_hdr->sh_type = SHT_NOBITS;
2443       else
2444         this_hdr->sh_type = SHT_PROGBITS;
2445     }
2446
2447   switch (this_hdr->sh_type)
2448     {
2449     default:
2450       break;
2451
2452     case SHT_STRTAB:
2453     case SHT_INIT_ARRAY:
2454     case SHT_FINI_ARRAY:
2455     case SHT_PREINIT_ARRAY:
2456     case SHT_NOTE:
2457     case SHT_NOBITS:
2458     case SHT_PROGBITS:
2459       break;
2460
2461     case SHT_HASH:
2462       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2463       break;
2464
2465     case SHT_DYNSYM:
2466       this_hdr->sh_entsize = bed->s->sizeof_sym;
2467       break;
2468
2469     case SHT_DYNAMIC:
2470       this_hdr->sh_entsize = bed->s->sizeof_dyn;
2471       break;
2472
2473     case SHT_RELA:
2474       if (get_elf_backend_data (abfd)->may_use_rela_p)
2475         this_hdr->sh_entsize = bed->s->sizeof_rela;
2476       break;
2477
2478      case SHT_REL:
2479       if (get_elf_backend_data (abfd)->may_use_rel_p)
2480         this_hdr->sh_entsize = bed->s->sizeof_rel;
2481       break;
2482
2483      case SHT_GNU_versym:
2484       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2485       break;
2486
2487      case SHT_GNU_verdef:
2488       this_hdr->sh_entsize = 0;
2489       /* objcopy or strip will copy over sh_info, but may not set
2490          cverdefs.  The linker will set cverdefs, but sh_info will be
2491          zero.  */
2492       if (this_hdr->sh_info == 0)
2493         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2494       else
2495         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2496                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2497       break;
2498
2499     case SHT_GNU_verneed:
2500       this_hdr->sh_entsize = 0;
2501       /* objcopy or strip will copy over sh_info, but may not set
2502          cverrefs.  The linker will set cverrefs, but sh_info will be
2503          zero.  */
2504       if (this_hdr->sh_info == 0)
2505         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2506       else
2507         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2508                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2509       break;
2510
2511     case SHT_GROUP:
2512       this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2513       break;
2514
2515     case SHT_GNU_HASH:
2516       this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2517       break;
2518     }
2519
2520   if ((asect->flags & SEC_ALLOC) != 0)
2521     this_hdr->sh_flags |= SHF_ALLOC;
2522   if ((asect->flags & SEC_READONLY) == 0)
2523     this_hdr->sh_flags |= SHF_WRITE;
2524   if ((asect->flags & SEC_CODE) != 0)
2525     this_hdr->sh_flags |= SHF_EXECINSTR;
2526   if ((asect->flags & SEC_MERGE) != 0)
2527     {
2528       this_hdr->sh_flags |= SHF_MERGE;
2529       this_hdr->sh_entsize = asect->entsize;
2530       if ((asect->flags & SEC_STRINGS) != 0)
2531         this_hdr->sh_flags |= SHF_STRINGS;
2532     }
2533   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2534     this_hdr->sh_flags |= SHF_GROUP;
2535   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2536     {
2537       this_hdr->sh_flags |= SHF_TLS;
2538       if (asect->size == 0
2539           && (asect->flags & SEC_HAS_CONTENTS) == 0)
2540         {
2541           struct bfd_link_order *o = asect->map_tail.link_order;
2542
2543           this_hdr->sh_size = 0;
2544           if (o != NULL)
2545             {
2546               this_hdr->sh_size = o->offset + o->size;
2547               if (this_hdr->sh_size != 0)
2548                 this_hdr->sh_type = SHT_NOBITS;
2549             }
2550         }
2551     }
2552
2553   /* Check for processor-specific section types.  */
2554   sh_type = this_hdr->sh_type;
2555   if (bed->elf_backend_fake_sections
2556       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2557     *failedptr = TRUE;
2558
2559   if (sh_type == SHT_NOBITS && asect->size != 0)
2560     {
2561       /* Don't change the header type from NOBITS if we are being
2562          called for objcopy --only-keep-debug.  */
2563       this_hdr->sh_type = sh_type;
2564     }
2565
2566   /* If the section has relocs, set up a section header for the
2567      SHT_REL[A] section.  If two relocation sections are required for
2568      this section, it is up to the processor-specific back-end to
2569      create the other.  */
2570   if ((asect->flags & SEC_RELOC) != 0
2571       && !_bfd_elf_init_reloc_shdr (abfd,
2572                                     &elf_section_data (asect)->rel_hdr,
2573                                     asect,
2574                                     asect->use_rela_p))
2575     *failedptr = TRUE;
2576 }
2577
2578 /* Fill in the contents of a SHT_GROUP section.  */
2579
2580 void
2581 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2582 {
2583   bfd_boolean *failedptr = failedptrarg;
2584   unsigned long symindx;
2585   asection *elt, *first;
2586   unsigned char *loc;
2587   bfd_boolean gas;
2588
2589   /* Ignore linker created group section.  See elfNN_ia64_object_p in
2590      elfxx-ia64.c.  */
2591   if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2592       || *failedptr)
2593     return;
2594
2595   symindx = 0;
2596   if (elf_group_id (sec) != NULL)
2597     symindx = elf_group_id (sec)->udata.i;
2598
2599   if (symindx == 0)
2600     {
2601       /* If called from the assembler, swap_out_syms will have set up
2602          elf_section_syms;  If called for "ld -r", use target_index.  */
2603       if (elf_section_syms (abfd) != NULL)
2604         symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2605       else
2606         symindx = sec->target_index;
2607     }
2608   elf_section_data (sec)->this_hdr.sh_info = symindx;
2609
2610   /* The contents won't be allocated for "ld -r" or objcopy.  */
2611   gas = TRUE;
2612   if (sec->contents == NULL)
2613     {
2614       gas = FALSE;
2615       sec->contents = bfd_alloc (abfd, sec->size);
2616
2617       /* Arrange for the section to be written out.  */
2618       elf_section_data (sec)->this_hdr.contents = sec->contents;
2619       if (sec->contents == NULL)
2620         {
2621           *failedptr = TRUE;
2622           return;
2623         }
2624     }
2625
2626   loc = sec->contents + sec->size;
2627
2628   /* Get the pointer to the first section in the group that gas
2629      squirreled away here.  objcopy arranges for this to be set to the
2630      start of the input section group.  */
2631   first = elt = elf_next_in_group (sec);
2632
2633   /* First element is a flag word.  Rest of section is elf section
2634      indices for all the sections of the group.  Write them backwards
2635      just to keep the group in the same order as given in .section
2636      directives, not that it matters.  */
2637   while (elt != NULL)
2638     {
2639       asection *s;
2640       unsigned int idx;
2641
2642       loc -= 4;
2643       s = elt;
2644       if (!gas)
2645         s = s->output_section;
2646       idx = 0;
2647       if (s != NULL)
2648         idx = elf_section_data (s)->this_idx;
2649       H_PUT_32 (abfd, idx, loc);
2650       elt = elf_next_in_group (elt);
2651       if (elt == first)
2652         break;
2653     }
2654
2655   if ((loc -= 4) != sec->contents)
2656     abort ();
2657
2658   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2659 }
2660
2661 /* Assign all ELF section numbers.  The dummy first section is handled here
2662    too.  The link/info pointers for the standard section types are filled
2663    in here too, while we're at it.  */
2664
2665 static bfd_boolean
2666 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2667 {
2668   struct elf_obj_tdata *t = elf_tdata (abfd);
2669   asection *sec;
2670   unsigned int section_number, secn;
2671   Elf_Internal_Shdr **i_shdrp;
2672   struct bfd_elf_section_data *d;
2673
2674   section_number = 1;
2675
2676   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2677
2678   /* SHT_GROUP sections are in relocatable files only.  */
2679   if (link_info == NULL || link_info->relocatable)
2680     {
2681       /* Put SHT_GROUP sections first.  */
2682       for (sec = abfd->sections; sec != NULL; sec = sec->next)
2683         {
2684           d = elf_section_data (sec);
2685
2686           if (d->this_hdr.sh_type == SHT_GROUP)
2687             {
2688               if (sec->flags & SEC_LINKER_CREATED)
2689                 {
2690                   /* Remove the linker created SHT_GROUP sections.  */
2691                   bfd_section_list_remove (abfd, sec);
2692                   abfd->section_count--;
2693                 }
2694               else
2695                 {
2696                   if (section_number == SHN_LORESERVE)
2697                     section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2698                   d->this_idx = section_number++;
2699                 }
2700             }
2701         }
2702     }
2703
2704   for (sec = abfd->sections; sec; sec = sec->next)
2705     {
2706       d = elf_section_data (sec);
2707
2708       if (d->this_hdr.sh_type != SHT_GROUP)
2709         {
2710           if (section_number == SHN_LORESERVE)
2711             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2712           d->this_idx = section_number++;
2713         }
2714       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2715       if ((sec->flags & SEC_RELOC) == 0)
2716         d->rel_idx = 0;
2717       else
2718         {
2719           if (section_number == SHN_LORESERVE)
2720             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2721           d->rel_idx = section_number++;
2722           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2723         }
2724
2725       if (d->rel_hdr2)
2726         {
2727           if (section_number == SHN_LORESERVE)
2728             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2729           d->rel_idx2 = section_number++;
2730           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2731         }
2732       else
2733         d->rel_idx2 = 0;
2734     }
2735
2736   if (section_number == SHN_LORESERVE)
2737     section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2738   t->shstrtab_section = section_number++;
2739   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2740   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2741
2742   if (bfd_get_symcount (abfd) > 0)
2743     {
2744       if (section_number == SHN_LORESERVE)
2745         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2746       t->symtab_section = section_number++;
2747       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2748       if (section_number > SHN_LORESERVE - 2)
2749         {
2750           if (section_number == SHN_LORESERVE)
2751             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2752           t->symtab_shndx_section = section_number++;
2753           t->symtab_shndx_hdr.sh_name
2754             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2755                                                   ".symtab_shndx", FALSE);
2756           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2757             return FALSE;
2758         }
2759       if (section_number == SHN_LORESERVE)
2760         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2761       t->strtab_section = section_number++;
2762       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2763     }
2764
2765   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2766   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2767
2768   elf_numsections (abfd) = section_number;
2769   elf_elfheader (abfd)->e_shnum = section_number;
2770   if (section_number > SHN_LORESERVE)
2771     elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2772
2773   /* Set up the list of section header pointers, in agreement with the
2774      indices.  */
2775   i_shdrp = bfd_zalloc2 (abfd, section_number, sizeof (Elf_Internal_Shdr *));
2776   if (i_shdrp == NULL)
2777     return FALSE;
2778
2779   i_shdrp[0] = bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
2780   if (i_shdrp[0] == NULL)
2781     {
2782       bfd_release (abfd, i_shdrp);
2783       return FALSE;
2784     }
2785
2786   elf_elfsections (abfd) = i_shdrp;
2787
2788   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2789   if (bfd_get_symcount (abfd) > 0)
2790     {
2791       i_shdrp[t->symtab_section] = &t->symtab_hdr;
2792       if (elf_numsections (abfd) > SHN_LORESERVE)
2793         {
2794           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2795           t->symtab_shndx_hdr.sh_link = t->symtab_section;
2796         }
2797       i_shdrp[t->strtab_section] = &t->strtab_hdr;
2798       t->symtab_hdr.sh_link = t->strtab_section;
2799     }
2800
2801   for (sec = abfd->sections; sec; sec = sec->next)
2802     {
2803       struct bfd_elf_section_data *d = elf_section_data (sec);
2804       asection *s;
2805       const char *name;
2806
2807       i_shdrp[d->this_idx] = &d->this_hdr;
2808       if (d->rel_idx != 0)
2809         i_shdrp[d->rel_idx] = &d->rel_hdr;
2810       if (d->rel_idx2 != 0)
2811         i_shdrp[d->rel_idx2] = d->rel_hdr2;
2812
2813       /* Fill in the sh_link and sh_info fields while we're at it.  */
2814
2815       /* sh_link of a reloc section is the section index of the symbol
2816          table.  sh_info is the section index of the section to which
2817          the relocation entries apply.  */
2818       if (d->rel_idx != 0)
2819         {
2820           d->rel_hdr.sh_link = t->symtab_section;
2821           d->rel_hdr.sh_info = d->this_idx;
2822         }
2823       if (d->rel_idx2 != 0)
2824         {
2825           d->rel_hdr2->sh_link = t->symtab_section;
2826           d->rel_hdr2->sh_info = d->this_idx;
2827         }
2828
2829       /* We need to set up sh_link for SHF_LINK_ORDER.  */
2830       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
2831         {
2832           s = elf_linked_to_section (sec);
2833           if (s)
2834             {
2835               /* elf_linked_to_section points to the input section.  */
2836               if (link_info != NULL)
2837                 {
2838                   /* Check discarded linkonce section.  */
2839                   if (elf_discarded_section (s))
2840                     {
2841                       asection *kept;
2842                       (*_bfd_error_handler)
2843                         (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2844                          abfd, d->this_hdr.bfd_section,
2845                          s, s->owner);
2846                       /* Point to the kept section if it has the same
2847                          size as the discarded one.  */
2848                       kept = _bfd_elf_check_kept_section (s, link_info);
2849                       if (kept == NULL)
2850                         {
2851                           bfd_set_error (bfd_error_bad_value);
2852                           return FALSE;
2853                         }
2854                       s = kept;
2855                     }
2856
2857                   s = s->output_section;
2858                   BFD_ASSERT (s != NULL);
2859                 }
2860               else
2861                 {
2862                   /* Handle objcopy. */
2863                   if (s->output_section == NULL)
2864                     {
2865                       (*_bfd_error_handler)
2866                         (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2867                          abfd, d->this_hdr.bfd_section, s, s->owner);
2868                       bfd_set_error (bfd_error_bad_value);
2869                       return FALSE;
2870                     }
2871                   s = s->output_section;
2872                 }
2873               d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2874             }
2875           else
2876             {
2877               /* PR 290:
2878                  The Intel C compiler generates SHT_IA_64_UNWIND with
2879                  SHF_LINK_ORDER.  But it doesn't set the sh_link or
2880                  sh_info fields.  Hence we could get the situation
2881                  where s is NULL.  */
2882               const struct elf_backend_data *bed
2883                 = get_elf_backend_data (abfd);
2884               if (bed->link_order_error_handler)
2885                 bed->link_order_error_handler
2886                   (_("%B: warning: sh_link not set for section `%A'"),
2887                    abfd, sec);
2888             }
2889         }
2890
2891       switch (d->this_hdr.sh_type)
2892         {
2893         case SHT_REL:
2894         case SHT_RELA:
2895           /* A reloc section which we are treating as a normal BFD
2896              section.  sh_link is the section index of the symbol
2897              table.  sh_info is the section index of the section to
2898              which the relocation entries apply.  We assume that an
2899              allocated reloc section uses the dynamic symbol table.
2900              FIXME: How can we be sure?  */
2901           s = bfd_get_section_by_name (abfd, ".dynsym");
2902           if (s != NULL)
2903             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2904
2905           /* We look up the section the relocs apply to by name.  */
2906           name = sec->name;
2907           if (d->this_hdr.sh_type == SHT_REL)
2908             name += 4;
2909           else
2910             name += 5;
2911           s = bfd_get_section_by_name (abfd, name);
2912           if (s != NULL)
2913             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2914           break;
2915
2916         case SHT_STRTAB:
2917           /* We assume that a section named .stab*str is a stabs
2918              string section.  We look for a section with the same name
2919              but without the trailing ``str'', and set its sh_link
2920              field to point to this section.  */
2921           if (CONST_STRNEQ (sec->name, ".stab")
2922               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2923             {
2924               size_t len;
2925               char *alc;
2926
2927               len = strlen (sec->name);
2928               alc = bfd_malloc (len - 2);
2929               if (alc == NULL)
2930                 return FALSE;
2931               memcpy (alc, sec->name, len - 3);
2932               alc[len - 3] = '\0';
2933               s = bfd_get_section_by_name (abfd, alc);
2934               free (alc);
2935               if (s != NULL)
2936                 {
2937                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2938
2939                   /* This is a .stab section.  */
2940                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
2941                     elf_section_data (s)->this_hdr.sh_entsize
2942                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
2943                 }
2944             }
2945           break;
2946
2947         case SHT_DYNAMIC:
2948         case SHT_DYNSYM:
2949         case SHT_GNU_verneed:
2950         case SHT_GNU_verdef:
2951           /* sh_link is the section header index of the string table
2952              used for the dynamic entries, or the symbol table, or the
2953              version strings.  */
2954           s = bfd_get_section_by_name (abfd, ".dynstr");
2955           if (s != NULL)
2956             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2957           break;
2958
2959         case SHT_GNU_LIBLIST:
2960           /* sh_link is the section header index of the prelink library
2961              list used for the dynamic entries, or the symbol table, or
2962              the version strings.  */
2963           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
2964                                              ? ".dynstr" : ".gnu.libstr");
2965           if (s != NULL)
2966             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2967           break;
2968
2969         case SHT_HASH:
2970         case SHT_GNU_HASH:
2971         case SHT_GNU_versym:
2972           /* sh_link is the section header index of the symbol table
2973              this hash table or version table is for.  */
2974           s = bfd_get_section_by_name (abfd, ".dynsym");
2975           if (s != NULL)
2976             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2977           break;
2978
2979         case SHT_GROUP:
2980           d->this_hdr.sh_link = t->symtab_section;
2981         }
2982     }
2983
2984   for (secn = 1; secn < section_number; ++secn)
2985     if (i_shdrp[secn] == NULL)
2986       i_shdrp[secn] = i_shdrp[0];
2987     else
2988       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
2989                                                        i_shdrp[secn]->sh_name);
2990   return TRUE;
2991 }
2992
2993 /* Map symbol from it's internal number to the external number, moving
2994    all local symbols to be at the head of the list.  */
2995
2996 static bfd_boolean
2997 sym_is_global (bfd *abfd, asymbol *sym)
2998 {
2999   /* If the backend has a special mapping, use it.  */
3000   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3001   if (bed->elf_backend_sym_is_global)
3002     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3003
3004   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3005           || bfd_is_und_section (bfd_get_section (sym))
3006           || bfd_is_com_section (bfd_get_section (sym)));
3007 }
3008
3009 /* Don't output section symbols for sections that are not going to be
3010    output.  Also, don't output section symbols for reloc and other
3011    special sections.  */
3012
3013 static bfd_boolean
3014 ignore_section_sym (bfd *abfd, asymbol *sym)
3015 {
3016   return ((sym->flags & BSF_SECTION_SYM) != 0
3017           && (sym->value != 0
3018               || (sym->section->owner != abfd
3019                   && (sym->section->output_section->owner != abfd
3020                       || sym->section->output_offset != 0))));
3021 }
3022
3023 static bfd_boolean
3024 elf_map_symbols (bfd *abfd)
3025 {
3026   unsigned int symcount = bfd_get_symcount (abfd);
3027   asymbol **syms = bfd_get_outsymbols (abfd);
3028   asymbol **sect_syms;
3029   unsigned int num_locals = 0;
3030   unsigned int num_globals = 0;
3031   unsigned int num_locals2 = 0;
3032   unsigned int num_globals2 = 0;
3033   int max_index = 0;
3034   unsigned int idx;
3035   asection *asect;
3036   asymbol **new_syms;
3037
3038 #ifdef DEBUG
3039   fprintf (stderr, "elf_map_symbols\n");
3040   fflush (stderr);
3041 #endif
3042
3043   for (asect = abfd->sections; asect; asect = asect->next)
3044     {
3045       if (max_index < asect->index)
3046         max_index = asect->index;
3047     }
3048
3049   max_index++;
3050   sect_syms = bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3051   if (sect_syms == NULL)
3052     return FALSE;
3053   elf_section_syms (abfd) = sect_syms;
3054   elf_num_section_syms (abfd) = max_index;
3055
3056   /* Init sect_syms entries for any section symbols we have already
3057      decided to output.  */
3058   for (idx = 0; idx < symcount; idx++)
3059     {
3060       asymbol *sym = syms[idx];
3061
3062       if ((sym->flags & BSF_SECTION_SYM) != 0
3063           && !ignore_section_sym (abfd, sym))
3064         {
3065           asection *sec = sym->section;
3066
3067           if (sec->owner != abfd)
3068             sec = sec->output_section;
3069
3070           sect_syms[sec->index] = syms[idx];
3071         }
3072     }
3073
3074   /* Classify all of the symbols.  */
3075   for (idx = 0; idx < symcount; idx++)
3076     {
3077       if (ignore_section_sym (abfd, syms[idx]))
3078         continue;
3079       if (!sym_is_global (abfd, syms[idx]))
3080         num_locals++;
3081       else
3082         num_globals++;
3083     }
3084
3085   /* We will be adding a section symbol for each normal BFD section.  Most
3086      sections will already have a section symbol in outsymbols, but
3087      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3088      at least in that case.  */
3089   for (asect = abfd->sections; asect; asect = asect->next)
3090     {
3091       if (sect_syms[asect->index] == NULL)
3092         {
3093           if (!sym_is_global (abfd, asect->symbol))
3094             num_locals++;
3095           else
3096             num_globals++;
3097         }
3098     }
3099
3100   /* Now sort the symbols so the local symbols are first.  */
3101   new_syms = bfd_alloc2 (abfd, num_locals + num_globals, sizeof (asymbol *));
3102
3103   if (new_syms == NULL)
3104     return FALSE;
3105
3106   for (idx = 0; idx < symcount; idx++)
3107     {
3108       asymbol *sym = syms[idx];
3109       unsigned int i;
3110
3111       if (ignore_section_sym (abfd, sym))
3112         continue;
3113       if (!sym_is_global (abfd, sym))
3114         i = num_locals2++;
3115       else
3116         i = num_locals + num_globals2++;
3117       new_syms[i] = sym;
3118       sym->udata.i = i + 1;
3119     }
3120   for (asect = abfd->sections; asect; asect = asect->next)
3121     {
3122       if (sect_syms[asect->index] == NULL)
3123         {
3124           asymbol *sym = asect->symbol;
3125           unsigned int i;
3126
3127           sect_syms[asect->index] = sym;
3128           if (!sym_is_global (abfd, sym))
3129             i = num_locals2++;
3130           else
3131             i = num_locals + num_globals2++;
3132           new_syms[i] = sym;
3133           sym->udata.i = i + 1;
3134         }
3135     }
3136
3137   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3138
3139   elf_num_locals (abfd) = num_locals;
3140   elf_num_globals (abfd) = num_globals;
3141   return TRUE;
3142 }
3143
3144 /* Align to the maximum file alignment that could be required for any
3145    ELF data structure.  */
3146
3147 static inline file_ptr
3148 align_file_position (file_ptr off, int align)
3149 {
3150   return (off + align - 1) & ~(align - 1);
3151 }
3152
3153 /* Assign a file position to a section, optionally aligning to the
3154    required section alignment.  */
3155
3156 file_ptr
3157 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3158                                            file_ptr offset,
3159                                            bfd_boolean align)
3160 {
3161   if (align)
3162     {
3163       unsigned int al;
3164
3165       al = i_shdrp->sh_addralign;
3166       if (al > 1)
3167         offset = BFD_ALIGN (offset, al);
3168     }
3169   i_shdrp->sh_offset = offset;
3170   if (i_shdrp->bfd_section != NULL)
3171     i_shdrp->bfd_section->filepos = offset;
3172   if (i_shdrp->sh_type != SHT_NOBITS)
3173     offset += i_shdrp->sh_size;
3174   return offset;
3175 }
3176
3177 /* Compute the file positions we are going to put the sections at, and
3178    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3179    is not NULL, this is being called by the ELF backend linker.  */
3180
3181 bfd_boolean
3182 _bfd_elf_compute_section_file_positions (bfd *abfd,
3183                                          struct bfd_link_info *link_info)
3184 {
3185   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3186   bfd_boolean failed;
3187   struct bfd_strtab_hash *strtab = NULL;
3188   Elf_Internal_Shdr *shstrtab_hdr;
3189
3190   if (abfd->output_has_begun)
3191     return TRUE;
3192
3193   /* Do any elf backend specific processing first.  */
3194   if (bed->elf_backend_begin_write_processing)
3195     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3196
3197   if (! prep_headers (abfd))
3198     return FALSE;
3199
3200   /* Post process the headers if necessary.  */
3201   if (bed->elf_backend_post_process_headers)
3202     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3203
3204   failed = FALSE;
3205   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3206   if (failed)
3207     return FALSE;
3208
3209   if (!assign_section_numbers (abfd, link_info))
3210     return FALSE;
3211
3212   /* The backend linker builds symbol table information itself.  */
3213   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3214     {
3215       /* Non-zero if doing a relocatable link.  */
3216       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3217
3218       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3219         return FALSE;
3220     }
3221
3222   if (link_info == NULL)
3223     {
3224       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3225       if (failed)
3226         return FALSE;
3227     }
3228
3229   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3230   /* sh_name was set in prep_headers.  */
3231   shstrtab_hdr->sh_type = SHT_STRTAB;
3232   shstrtab_hdr->sh_flags = 0;
3233   shstrtab_hdr->sh_addr = 0;
3234   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3235   shstrtab_hdr->sh_entsize = 0;
3236   shstrtab_hdr->sh_link = 0;
3237   shstrtab_hdr->sh_info = 0;
3238   /* sh_offset is set in assign_file_positions_except_relocs.  */
3239   shstrtab_hdr->sh_addralign = 1;
3240
3241   if (!assign_file_positions_except_relocs (abfd, link_info))
3242     return FALSE;
3243
3244   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3245     {
3246       file_ptr off;
3247       Elf_Internal_Shdr *hdr;
3248
3249       off = elf_tdata (abfd)->next_file_pos;
3250
3251       hdr = &elf_tdata (abfd)->symtab_hdr;
3252       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3253
3254       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3255       if (hdr->sh_size != 0)
3256         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3257
3258       hdr = &elf_tdata (abfd)->strtab_hdr;
3259       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3260
3261       elf_tdata (abfd)->next_file_pos = off;
3262
3263       /* Now that we know where the .strtab section goes, write it
3264          out.  */
3265       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3266           || ! _bfd_stringtab_emit (abfd, strtab))
3267         return FALSE;
3268       _bfd_stringtab_free (strtab);
3269     }
3270
3271   abfd->output_has_begun = TRUE;
3272
3273   return TRUE;
3274 }
3275
3276 /* Make an initial estimate of the size of the program header.  If we
3277    get the number wrong here, we'll redo section placement.  */
3278
3279 static bfd_size_type
3280 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3281 {
3282   size_t segs;
3283   asection *s;
3284   const struct elf_backend_data *bed;
3285
3286   /* Assume we will need exactly two PT_LOAD segments: one for text
3287      and one for data.  */
3288   segs = 2;
3289
3290   s = bfd_get_section_by_name (abfd, ".interp");
3291   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3292     {
3293       /* If we have a loadable interpreter section, we need a
3294          PT_INTERP segment.  In this case, assume we also need a
3295          PT_PHDR segment, although that may not be true for all
3296          targets.  */
3297       segs += 2;
3298     }
3299
3300   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3301     {
3302       /* We need a PT_DYNAMIC segment.  */
3303       ++segs;
3304
3305       if (elf_tdata (abfd)->relro)
3306         {
3307           /* We need a PT_GNU_RELRO segment only when there is a
3308              PT_DYNAMIC segment.  */
3309           ++segs;
3310         }
3311     }
3312
3313   if (elf_tdata (abfd)->eh_frame_hdr)
3314     {
3315       /* We need a PT_GNU_EH_FRAME segment.  */
3316       ++segs;
3317     }
3318
3319   if (elf_tdata (abfd)->stack_flags)
3320     {
3321       /* We need a PT_GNU_STACK segment.  */
3322       ++segs;
3323     }
3324
3325   for (s = abfd->sections; s != NULL; s = s->next)
3326     {
3327       if ((s->flags & SEC_LOAD) != 0
3328           && CONST_STRNEQ (s->name, ".note"))
3329         {
3330           /* We need a PT_NOTE segment.  */
3331           ++segs;
3332         }
3333     }
3334
3335   for (s = abfd->sections; s != NULL; s = s->next)
3336     {
3337       if (s->flags & SEC_THREAD_LOCAL)
3338         {
3339           /* We need a PT_TLS segment.  */
3340           ++segs;
3341           break;
3342         }
3343     }
3344
3345   /* Let the backend count up any program headers it might need.  */
3346   bed = get_elf_backend_data (abfd);
3347   if (bed->elf_backend_additional_program_headers)
3348     {
3349       int a;
3350
3351       a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3352       if (a == -1)
3353         abort ();
3354       segs += a;
3355     }
3356
3357   return segs * bed->s->sizeof_phdr;
3358 }
3359
3360 /* Create a mapping from a set of sections to a program segment.  */
3361
3362 static struct elf_segment_map *
3363 make_mapping (bfd *abfd,
3364               asection **sections,
3365               unsigned int from,
3366               unsigned int to,
3367               bfd_boolean phdr)
3368 {
3369   struct elf_segment_map *m;
3370   unsigned int i;
3371   asection **hdrpp;
3372   bfd_size_type amt;
3373
3374   amt = sizeof (struct elf_segment_map);
3375   amt += (to - from - 1) * sizeof (asection *);
3376   m = bfd_zalloc (abfd, amt);
3377   if (m == NULL)
3378     return NULL;
3379   m->next = NULL;
3380   m->p_type = PT_LOAD;
3381   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3382     m->sections[i - from] = *hdrpp;
3383   m->count = to - from;
3384
3385   if (from == 0 && phdr)
3386     {
3387       /* Include the headers in the first PT_LOAD segment.  */
3388       m->includes_filehdr = 1;
3389       m->includes_phdrs = 1;
3390     }
3391
3392   return m;
3393 }
3394
3395 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
3396    on failure.  */
3397
3398 struct elf_segment_map *
3399 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3400 {
3401   struct elf_segment_map *m;
3402
3403   m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3404   if (m == NULL)
3405     return NULL;
3406   m->next = NULL;
3407   m->p_type = PT_DYNAMIC;
3408   m->count = 1;
3409   m->sections[0] = dynsec;
3410
3411   return m;
3412 }
3413
3414 /* Possibly add or remove segments from the segment map.  */
3415
3416 static bfd_boolean
3417 elf_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
3418 {
3419   struct elf_segment_map **m;
3420   const struct elf_backend_data *bed;
3421
3422   /* The placement algorithm assumes that non allocated sections are
3423      not in PT_LOAD segments.  We ensure this here by removing such
3424      sections from the segment map.  We also remove excluded
3425      sections.  Finally, any PT_LOAD segment without sections is
3426      removed.  */
3427   m = &elf_tdata (abfd)->segment_map;
3428   while (*m)
3429     {
3430       unsigned int i, new_count;
3431
3432       for (new_count = 0, i = 0; i < (*m)->count; i++)
3433         {
3434           if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3435               && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3436                   || (*m)->p_type != PT_LOAD))
3437             {
3438               (*m)->sections[new_count] = (*m)->sections[i];
3439               new_count++;
3440             }
3441         }
3442       (*m)->count = new_count;
3443
3444       if ((*m)->p_type == PT_LOAD && (*m)->count == 0)
3445         *m = (*m)->next;
3446       else
3447         m = &(*m)->next;
3448     }
3449
3450   bed = get_elf_backend_data (abfd);
3451   if (bed->elf_backend_modify_segment_map != NULL)
3452     {
3453       if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3454         return FALSE;
3455     }
3456
3457   return TRUE;
3458 }
3459
3460 /* Set up a mapping from BFD sections to program segments.  */
3461
3462 bfd_boolean
3463 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3464 {
3465   unsigned int count;
3466   struct elf_segment_map *m;
3467   asection **sections = NULL;
3468   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3469
3470   if (elf_tdata (abfd)->segment_map == NULL
3471       && bfd_count_sections (abfd) != 0)
3472     {
3473       asection *s;
3474       unsigned int i;
3475       struct elf_segment_map *mfirst;
3476       struct elf_segment_map **pm;
3477       asection *last_hdr;
3478       bfd_vma last_size;
3479       unsigned int phdr_index;
3480       bfd_vma maxpagesize;
3481       asection **hdrpp;
3482       bfd_boolean phdr_in_segment = TRUE;
3483       bfd_boolean writable;
3484       int tls_count = 0;
3485       asection *first_tls = NULL;
3486       asection *dynsec, *eh_frame_hdr;
3487       bfd_size_type amt;
3488
3489       /* Select the allocated sections, and sort them.  */
3490
3491       sections = bfd_malloc2 (bfd_count_sections (abfd), sizeof (asection *));
3492       if (sections == NULL)
3493         goto error_return;
3494
3495       i = 0;
3496       for (s = abfd->sections; s != NULL; s = s->next)
3497         {
3498           if ((s->flags & SEC_ALLOC) != 0)
3499             {
3500               sections[i] = s;
3501               ++i;
3502             }
3503         }
3504       BFD_ASSERT (i <= bfd_count_sections (abfd));
3505       count = i;
3506
3507       qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3508
3509       /* Build the mapping.  */
3510
3511       mfirst = NULL;
3512       pm = &mfirst;
3513
3514       /* If we have a .interp section, then create a PT_PHDR segment for
3515          the program headers and a PT_INTERP segment for the .interp
3516          section.  */
3517       s = bfd_get_section_by_name (abfd, ".interp");
3518       if (s != NULL && (s->flags & SEC_LOAD) != 0)
3519         {
3520           amt = sizeof (struct elf_segment_map);
3521           m = bfd_zalloc (abfd, amt);
3522           if (m == NULL)
3523             goto error_return;
3524           m->next = NULL;
3525           m->p_type = PT_PHDR;
3526           /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3527           m->p_flags = PF_R | PF_X;
3528           m->p_flags_valid = 1;
3529           m->includes_phdrs = 1;
3530
3531           *pm = m;
3532           pm = &m->next;
3533
3534           amt = sizeof (struct elf_segment_map);
3535           m = bfd_zalloc (abfd, amt);
3536           if (m == NULL)
3537             goto error_return;
3538           m->next = NULL;
3539           m->p_type = PT_INTERP;
3540           m->count = 1;
3541           m->sections[0] = s;
3542
3543           *pm = m;
3544           pm = &m->next;
3545         }
3546
3547       /* Look through the sections.  We put sections in the same program
3548          segment when the start of the second section can be placed within
3549          a few bytes of the end of the first section.  */
3550       last_hdr = NULL;
3551       last_size = 0;
3552       phdr_index = 0;
3553       maxpagesize = bed->maxpagesize;
3554       writable = FALSE;
3555       dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3556       if (dynsec != NULL
3557           && (dynsec->flags & SEC_LOAD) == 0)
3558         dynsec = NULL;
3559
3560       /* Deal with -Ttext or something similar such that the first section
3561          is not adjacent to the program headers.  This is an
3562          approximation, since at this point we don't know exactly how many
3563          program headers we will need.  */
3564       if (count > 0)
3565         {
3566           bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3567
3568           if (phdr_size == (bfd_size_type) -1)
3569             phdr_size = get_program_header_size (abfd, info);
3570           if ((abfd->flags & D_PAGED) == 0
3571               || sections[0]->lma < phdr_size
3572               || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3573             phdr_in_segment = FALSE;
3574         }
3575
3576       for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3577         {
3578           asection *hdr;
3579           bfd_boolean new_segment;
3580
3581           hdr = *hdrpp;
3582
3583           /* See if this section and the last one will fit in the same
3584              segment.  */
3585
3586           if (last_hdr == NULL)
3587             {
3588               /* If we don't have a segment yet, then we don't need a new
3589                  one (we build the last one after this loop).  */
3590               new_segment = FALSE;
3591             }
3592           else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3593             {
3594               /* If this section has a different relation between the
3595                  virtual address and the load address, then we need a new
3596                  segment.  */
3597               new_segment = TRUE;
3598             }
3599           else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3600                    < BFD_ALIGN (hdr->lma, maxpagesize))
3601             {
3602               /* If putting this section in this segment would force us to
3603                  skip a page in the segment, then we need a new segment.  */
3604               new_segment = TRUE;
3605             }
3606           else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3607                    && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3608             {
3609               /* We don't want to put a loadable section after a
3610                  nonloadable section in the same segment.
3611                  Consider .tbss sections as loadable for this purpose.  */
3612               new_segment = TRUE;
3613             }
3614           else if ((abfd->flags & D_PAGED) == 0)
3615             {
3616               /* If the file is not demand paged, which means that we
3617                  don't require the sections to be correctly aligned in the
3618                  file, then there is no other reason for a new segment.  */
3619               new_segment = FALSE;
3620             }
3621           else if (! writable
3622                    && (hdr->flags & SEC_READONLY) == 0
3623                    && (((last_hdr->lma + last_size - 1)
3624                         & ~(maxpagesize - 1))
3625                        != (hdr->lma & ~(maxpagesize - 1))))
3626             {
3627               /* We don't want to put a writable section in a read only
3628                  segment, unless they are on the same page in memory
3629                  anyhow.  We already know that the last section does not
3630                  bring us past the current section on the page, so the
3631                  only case in which the new section is not on the same
3632                  page as the previous section is when the previous section
3633                  ends precisely on a page boundary.  */
3634               new_segment = TRUE;
3635             }
3636           else
3637             {
3638               /* Otherwise, we can use the same segment.  */
3639               new_segment = FALSE;
3640             }
3641
3642           /* Allow interested parties a chance to override our decision.  */
3643           if (last_hdr && info->callbacks->override_segment_assignment)
3644             new_segment = info->callbacks->override_segment_assignment (info, abfd, hdr, last_hdr, new_segment);
3645
3646           if (! new_segment)
3647             {
3648               if ((hdr->flags & SEC_READONLY) == 0)
3649                 writable = TRUE;
3650               last_hdr = hdr;
3651               /* .tbss sections effectively have zero size.  */
3652               if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3653                   != SEC_THREAD_LOCAL)
3654                 last_size = hdr->size;
3655               else
3656                 last_size = 0;
3657               continue;
3658             }
3659
3660           /* We need a new program segment.  We must create a new program
3661              header holding all the sections from phdr_index until hdr.  */
3662
3663           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3664           if (m == NULL)
3665             goto error_return;
3666
3667           *pm = m;
3668           pm = &m->next;
3669
3670           if ((hdr->flags & SEC_READONLY) == 0)
3671             writable = TRUE;
3672           else
3673             writable = FALSE;
3674
3675           last_hdr = hdr;
3676           /* .tbss sections effectively have zero size.  */
3677           if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3678             last_size = hdr->size;
3679           else
3680             last_size = 0;
3681           phdr_index = i;
3682           phdr_in_segment = FALSE;
3683         }
3684
3685       /* Create a final PT_LOAD program segment.  */
3686       if (last_hdr != NULL)
3687         {
3688           m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3689           if (m == NULL)
3690             goto error_return;
3691
3692           *pm = m;
3693           pm = &m->next;
3694         }
3695
3696       /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
3697       if (dynsec != NULL)
3698         {
3699           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3700           if (m == NULL)
3701             goto error_return;
3702           *pm = m;
3703           pm = &m->next;
3704         }
3705
3706       /* For each loadable .note section, add a PT_NOTE segment.  We don't
3707          use bfd_get_section_by_name, because if we link together
3708          nonloadable .note sections and loadable .note sections, we will
3709          generate two .note sections in the output file.  FIXME: Using
3710          names for section types is bogus anyhow.  */
3711       for (s = abfd->sections; s != NULL; s = s->next)
3712         {
3713           if ((s->flags & SEC_LOAD) != 0
3714               && CONST_STRNEQ (s->name, ".note"))
3715             {
3716               amt = sizeof (struct elf_segment_map);
3717               m = bfd_zalloc (abfd, amt);
3718               if (m == NULL)
3719                 goto error_return;
3720               m->next = NULL;
3721               m->p_type = PT_NOTE;
3722               m->count = 1;
3723               m->sections[0] = s;
3724
3725               *pm = m;
3726               pm = &m->next;
3727             }
3728           if (s->flags & SEC_THREAD_LOCAL)
3729             {
3730               if (! tls_count)
3731                 first_tls = s;
3732               tls_count++;
3733             }
3734         }
3735
3736       /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
3737       if (tls_count > 0)
3738         {
3739           int i;
3740
3741           amt = sizeof (struct elf_segment_map);
3742           amt += (tls_count - 1) * sizeof (asection *);
3743           m = bfd_zalloc (abfd, amt);
3744           if (m == NULL)
3745             goto error_return;
3746           m->next = NULL;
3747           m->p_type = PT_TLS;
3748           m->count = tls_count;
3749           /* Mandated PF_R.  */
3750           m->p_flags = PF_R;
3751           m->p_flags_valid = 1;
3752           for (i = 0; i < tls_count; ++i)
3753             {
3754               BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3755               m->sections[i] = first_tls;
3756               first_tls = first_tls->next;
3757             }
3758
3759           *pm = m;
3760           pm = &m->next;
3761         }
3762
3763       /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3764          segment.  */
3765       eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3766       if (eh_frame_hdr != NULL
3767           && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3768         {
3769           amt = sizeof (struct elf_segment_map);
3770           m = bfd_zalloc (abfd, amt);
3771           if (m == NULL)
3772             goto error_return;
3773           m->next = NULL;
3774           m->p_type = PT_GNU_EH_FRAME;
3775           m->count = 1;
3776           m->sections[0] = eh_frame_hdr->output_section;
3777
3778           *pm = m;
3779           pm = &m->next;
3780         }
3781
3782       if (elf_tdata (abfd)->stack_flags)
3783         {
3784           amt = sizeof (struct elf_segment_map);
3785           m = bfd_zalloc (abfd, amt);
3786           if (m == NULL)
3787             goto error_return;
3788           m->next = NULL;
3789           m->p_type = PT_GNU_STACK;
3790           m->p_flags = elf_tdata (abfd)->stack_flags;
3791           m->p_flags_valid = 1;
3792
3793           *pm = m;
3794           pm = &m->next;
3795         }
3796
3797       if (dynsec != NULL && elf_tdata (abfd)->relro)
3798         {
3799           /* We make a PT_GNU_RELRO segment only when there is a
3800              PT_DYNAMIC segment.  */
3801           amt = sizeof (struct elf_segment_map);
3802           m = bfd_zalloc (abfd, amt);
3803           if (m == NULL)
3804             goto error_return;
3805           m->next = NULL;
3806           m->p_type = PT_GNU_RELRO;
3807           m->p_flags = PF_R;
3808           m->p_flags_valid = 1;
3809
3810           *pm = m;
3811           pm = &m->next;
3812         }
3813
3814       free (sections);
3815       elf_tdata (abfd)->segment_map = mfirst;
3816     }
3817
3818   if (!elf_modify_segment_map (abfd, info))
3819     return FALSE;
3820
3821   for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3822     ++count;
3823   elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr;
3824
3825   return TRUE;
3826
3827  error_return:
3828   if (sections != NULL)
3829     free (sections);
3830   return FALSE;
3831 }
3832
3833 /* Sort sections by address.  */
3834
3835 static int
3836 elf_sort_sections (const void *arg1, const void *arg2)
3837 {
3838   const asection *sec1 = *(const asection **) arg1;
3839   const asection *sec2 = *(const asection **) arg2;
3840   bfd_size_type size1, size2;
3841
3842   /* Sort by LMA first, since this is the address used to
3843      place the section into a segment.  */
3844   if (sec1->lma < sec2->lma)
3845     return -1;
3846   else if (sec1->lma > sec2->lma)
3847     return 1;
3848
3849   /* Then sort by VMA.  Normally the LMA and the VMA will be
3850      the same, and this will do nothing.  */
3851   if (sec1->vma < sec2->vma)
3852     return -1;
3853   else if (sec1->vma > sec2->vma)
3854     return 1;
3855
3856   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
3857
3858 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3859
3860   if (TOEND (sec1))
3861     {
3862       if (TOEND (sec2))
3863         {
3864           /* If the indicies are the same, do not return 0
3865              here, but continue to try the next comparison.  */
3866           if (sec1->target_index - sec2->target_index != 0)
3867             return sec1->target_index - sec2->target_index;
3868         }
3869       else
3870         return 1;
3871     }
3872   else if (TOEND (sec2))
3873     return -1;
3874
3875 #undef TOEND
3876
3877   /* Sort by size, to put zero sized sections
3878      before others at the same address.  */
3879
3880   size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
3881   size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
3882
3883   if (size1 < size2)
3884     return -1;
3885   if (size1 > size2)
3886     return 1;
3887
3888   return sec1->target_index - sec2->target_index;
3889 }
3890
3891 /* Ian Lance Taylor writes:
3892
3893    We shouldn't be using % with a negative signed number.  That's just
3894    not good.  We have to make sure either that the number is not
3895    negative, or that the number has an unsigned type.  When the types
3896    are all the same size they wind up as unsigned.  When file_ptr is a
3897    larger signed type, the arithmetic winds up as signed long long,
3898    which is wrong.
3899
3900    What we're trying to say here is something like ``increase OFF by
3901    the least amount that will cause it to be equal to the VMA modulo
3902    the page size.''  */
3903 /* In other words, something like:
3904
3905    vma_offset = m->sections[0]->vma % bed->maxpagesize;
3906    off_offset = off % bed->maxpagesize;
3907    if (vma_offset < off_offset)
3908      adjustment = vma_offset + bed->maxpagesize - off_offset;
3909    else
3910      adjustment = vma_offset - off_offset;
3911
3912    which can can be collapsed into the expression below.  */
3913
3914 static file_ptr
3915 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
3916 {
3917   return ((vma - off) % maxpagesize);
3918 }
3919
3920 /* Assign file positions to the sections based on the mapping from
3921    sections to segments.  This function also sets up some fields in
3922    the file header.  */
3923
3924 static bfd_boolean
3925 assign_file_positions_for_load_sections (bfd *abfd,
3926                                          struct bfd_link_info *link_info)
3927 {
3928   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3929   struct elf_segment_map *m;
3930   Elf_Internal_Phdr *phdrs;
3931   Elf_Internal_Phdr *p;
3932   file_ptr off;
3933   bfd_size_type maxpagesize;
3934   unsigned int alloc;
3935   unsigned int i, j;
3936
3937   if (link_info == NULL
3938       && !elf_modify_segment_map (abfd, link_info))
3939     return FALSE;
3940
3941   alloc = 0;
3942   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3943     ++alloc;
3944
3945   elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3946   elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3947   elf_elfheader (abfd)->e_phnum = alloc;
3948
3949   if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1)
3950     elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr;
3951   else
3952     BFD_ASSERT (elf_tdata (abfd)->program_header_size
3953                 >= alloc * bed->s->sizeof_phdr);
3954
3955   if (alloc == 0)
3956     {
3957       elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
3958       return TRUE;
3959     }
3960
3961   phdrs = bfd_alloc2 (abfd, alloc, sizeof (Elf_Internal_Phdr));
3962   elf_tdata (abfd)->phdr = phdrs;
3963   if (phdrs == NULL)
3964     return FALSE;
3965
3966   maxpagesize = 1;
3967   if ((abfd->flags & D_PAGED) != 0)
3968     maxpagesize = bed->maxpagesize;
3969
3970   off = bed->s->sizeof_ehdr;
3971   off += alloc * bed->s->sizeof_phdr;
3972
3973   for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0;
3974        m != NULL;
3975        m = m->next, p++, j++)
3976     {
3977       asection **secpp;
3978       bfd_vma off_adjust;
3979       bfd_boolean no_contents;
3980
3981       /* If elf_segment_map is not from map_sections_to_segments, the
3982          sections may not be correctly ordered.  NOTE: sorting should
3983          not be done to the PT_NOTE section of a corefile, which may
3984          contain several pseudo-sections artificially created by bfd.
3985          Sorting these pseudo-sections breaks things badly.  */
3986       if (m->count > 1
3987           && !(elf_elfheader (abfd)->e_type == ET_CORE
3988                && m->p_type == PT_NOTE))
3989         qsort (m->sections, (size_t) m->count, sizeof (asection *),
3990                elf_sort_sections);
3991
3992       /* An ELF segment (described by Elf_Internal_Phdr) may contain a
3993          number of sections with contents contributing to both p_filesz
3994          and p_memsz, followed by a number of sections with no contents
3995          that just contribute to p_memsz.  In this loop, OFF tracks next
3996          available file offset for PT_LOAD and PT_NOTE segments.  */
3997       p->p_type = m->p_type;
3998       p->p_flags = m->p_flags;
3999
4000       if (m->count == 0)
4001         p->p_vaddr = 0;
4002       else
4003         p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
4004
4005       if (m->p_paddr_valid)
4006         p->p_paddr = m->p_paddr;
4007       else if (m->count == 0)
4008         p->p_paddr = 0;
4009       else
4010         p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
4011
4012       if (p->p_type == PT_LOAD
4013           && (abfd->flags & D_PAGED) != 0)
4014         {
4015           /* p_align in demand paged PT_LOAD segments effectively stores
4016              the maximum page size.  When copying an executable with
4017              objcopy, we set m->p_align from the input file.  Use this
4018              value for maxpagesize rather than bed->maxpagesize, which
4019              may be different.  Note that we use maxpagesize for PT_TLS
4020              segment alignment later in this function, so we are relying
4021              on at least one PT_LOAD segment appearing before a PT_TLS
4022              segment.  */
4023           if (m->p_align_valid)
4024             maxpagesize = m->p_align;
4025
4026           p->p_align = maxpagesize;
4027         }
4028       else if (m->count == 0)
4029         p->p_align = 1 << bed->s->log_file_align;
4030       else if (m->p_align_valid)
4031         p->p_align = m->p_align;
4032       else
4033         p->p_align = 0;
4034
4035       no_contents = FALSE;
4036       off_adjust = 0;
4037       if (p->p_type == PT_LOAD
4038           && m->count > 0)
4039         {
4040           bfd_size_type align;
4041           unsigned int align_power = 0;
4042
4043           if (m->p_align_valid)
4044             align = p->p_align;
4045           else
4046             {
4047               for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4048                 {
4049                   unsigned int secalign;
4050
4051                   secalign = bfd_get_section_alignment (abfd, *secpp);
4052                   if (secalign > align_power)
4053                     align_power = secalign;
4054                 }
4055               align = (bfd_size_type) 1 << align_power;
4056               if (align < maxpagesize)
4057                 align = maxpagesize;
4058             }
4059
4060           for (i = 0; i < m->count; i++)
4061             if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4062               /* If we aren't making room for this section, then
4063                  it must be SHT_NOBITS regardless of what we've
4064                  set via struct bfd_elf_special_section.  */
4065               elf_section_type (m->sections[i]) = SHT_NOBITS;
4066
4067           /* Find out whether this segment contains any loadable
4068              sections.  If the first section isn't loadable, the same
4069              holds for any other sections.  */
4070           i = 0;
4071           while (elf_section_type (m->sections[i]) == SHT_NOBITS)
4072             {
4073               /* If a segment starts with .tbss, we need to look
4074                  at the next section to decide whether the segment
4075                  has any loadable sections.  */
4076               if ((elf_section_flags (m->sections[i]) & SHF_TLS) == 0
4077                   || ++i >= m->count)
4078                 {
4079                   no_contents = TRUE;
4080                   break;
4081                 }
4082             }
4083
4084           off_adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4085           off += off_adjust;
4086           if (no_contents)
4087             {
4088               /* We shouldn't need to align the segment on disk since
4089                  the segment doesn't need file space, but the gABI
4090                  arguably requires the alignment and glibc ld.so
4091                  checks it.  So to comply with the alignment
4092                  requirement but not waste file space, we adjust
4093                  p_offset for just this segment.  (OFF_ADJUST is
4094                  subtracted from OFF later.)  This may put p_offset
4095                  past the end of file, but that shouldn't matter.  */
4096             }
4097           else
4098             off_adjust = 0;
4099         }
4100       /* Make sure the .dynamic section is the first section in the
4101          PT_DYNAMIC segment.  */
4102       else if (p->p_type == PT_DYNAMIC
4103                && m->count > 1
4104                && strcmp (m->sections[0]->name, ".dynamic") != 0)
4105         {
4106           _bfd_error_handler
4107             (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4108              abfd);
4109           bfd_set_error (bfd_error_bad_value);
4110           return FALSE;
4111         }
4112
4113       p->p_offset = 0;
4114       p->p_filesz = 0;
4115       p->p_memsz = 0;
4116
4117       if (m->includes_filehdr)
4118         {
4119           if (!m->p_flags_valid)
4120             p->p_flags |= PF_R;
4121           p->p_filesz = bed->s->sizeof_ehdr;
4122           p->p_memsz = bed->s->sizeof_ehdr;
4123           if (m->count > 0)
4124             {
4125               BFD_ASSERT (p->p_type == PT_LOAD);
4126
4127               if (p->p_vaddr < (bfd_vma) off)
4128                 {
4129                   (*_bfd_error_handler)
4130                     (_("%B: Not enough room for program headers, try linking with -N"),
4131                      abfd);
4132                   bfd_set_error (bfd_error_bad_value);
4133                   return FALSE;
4134                 }
4135
4136               p->p_vaddr -= off;
4137               if (!m->p_paddr_valid)
4138                 p->p_paddr -= off;
4139             }
4140         }
4141
4142       if (m->includes_phdrs)
4143         {
4144           if (!m->p_flags_valid)
4145             p->p_flags |= PF_R;
4146
4147           if (!m->includes_filehdr)
4148             {
4149               p->p_offset = bed->s->sizeof_ehdr;
4150
4151               if (m->count > 0)
4152                 {
4153                   BFD_ASSERT (p->p_type == PT_LOAD);
4154                   p->p_vaddr -= off - p->p_offset;
4155                   if (!m->p_paddr_valid)
4156                     p->p_paddr -= off - p->p_offset;
4157                 }
4158             }
4159
4160           p->p_filesz += alloc * bed->s->sizeof_phdr;
4161           p->p_memsz += alloc * bed->s->sizeof_phdr;
4162         }
4163
4164       if (p->p_type == PT_LOAD
4165           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4166         {
4167           if (!m->includes_filehdr && !m->includes_phdrs)
4168             p->p_offset = off;
4169           else
4170             {
4171               file_ptr adjust;
4172
4173               adjust = off - (p->p_offset + p->p_filesz);
4174               if (!no_contents)
4175                 p->p_filesz += adjust;
4176               p->p_memsz += adjust;
4177             }
4178         }
4179
4180       /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4181          maps.  Set filepos for sections in PT_LOAD segments, and in
4182          core files, for sections in PT_NOTE segments.
4183          assign_file_positions_for_non_load_sections will set filepos
4184          for other sections and update p_filesz for other segments.  */
4185       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4186         {
4187           asection *sec;
4188           bfd_size_type align;
4189           Elf_Internal_Shdr *this_hdr;
4190
4191           sec = *secpp;
4192           this_hdr = &elf_section_data (sec)->this_hdr;
4193           align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
4194
4195           if (p->p_type == PT_LOAD
4196               || p->p_type == PT_TLS)
4197             {
4198               bfd_signed_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
4199
4200               if (this_hdr->sh_type != SHT_NOBITS
4201                   || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4202                       && ((this_hdr->sh_flags & SHF_TLS) == 0
4203                           || p->p_type == PT_TLS)))
4204                 {
4205                   if (adjust < 0)
4206                     {
4207                       (*_bfd_error_handler)
4208                         (_("%B: section %A lma 0x%lx overlaps previous sections"),
4209                          abfd, sec, (unsigned long) sec->lma);
4210                       adjust = 0;
4211                     }
4212                   p->p_memsz += adjust;
4213
4214                   if (this_hdr->sh_type != SHT_NOBITS)
4215                     {
4216                       off += adjust;
4217                       p->p_filesz += adjust;
4218                     }
4219                 }
4220             }
4221
4222           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4223             {
4224               /* The section at i == 0 is the one that actually contains
4225                  everything.  */
4226               if (i == 0)
4227                 {
4228                   this_hdr->sh_offset = sec->filepos = off;
4229                   off += this_hdr->sh_size;
4230                   p->p_filesz = this_hdr->sh_size;
4231                   p->p_memsz = 0;
4232                   p->p_align = 1;
4233                 }
4234               else
4235                 {
4236                   /* The rest are fake sections that shouldn't be written.  */
4237                   sec->filepos = 0;
4238                   sec->size = 0;
4239                   sec->flags = 0;
4240                   continue;
4241                 }
4242             }
4243           else
4244             {
4245               if (p->p_type == PT_LOAD)
4246                 {
4247                   this_hdr->sh_offset = sec->filepos = off;
4248                   if (this_hdr->sh_type != SHT_NOBITS)
4249                     off += this_hdr->sh_size;
4250                 }
4251
4252               if (this_hdr->sh_type != SHT_NOBITS)
4253                 {
4254                   p->p_filesz += this_hdr->sh_size;
4255                   /* A load section without SHF_ALLOC is something like
4256                      a note section in a PT_NOTE segment.  These take
4257                      file space but are not loaded into memory.  */
4258                   if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4259                     p->p_memsz += this_hdr->sh_size;
4260                 }
4261               else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4262                 {
4263                   if (p->p_type == PT_TLS)
4264                     p->p_memsz += this_hdr->sh_size;
4265
4266                   /* .tbss is special.  It doesn't contribute to p_memsz of
4267                      normal segments.  */
4268                   else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4269                     p->p_memsz += this_hdr->sh_size;
4270                 }
4271
4272               if (p->p_type == PT_GNU_RELRO)
4273                 p->p_align = 1;
4274               else if (align > p->p_align
4275                        && !m->p_align_valid
4276                        && (p->p_type != PT_LOAD
4277                            || (abfd->flags & D_PAGED) == 0))
4278                 p->p_align = align;
4279             }
4280
4281           if (!m->p_flags_valid)
4282             {
4283               p->p_flags |= PF_R;
4284               if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4285                 p->p_flags |= PF_X;
4286               if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4287                 p->p_flags |= PF_W;
4288             }
4289         }
4290       off -= off_adjust;
4291
4292       /* Check that all sections are in a PT_LOAD segment.
4293          Don't check funky gdb generated core files.  */
4294       if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4295         for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4296           {
4297             Elf_Internal_Shdr *this_hdr;
4298             asection *sec;
4299
4300             sec = *secpp;
4301             this_hdr = &(elf_section_data(sec)->this_hdr);
4302             if (this_hdr->sh_size != 0
4303                 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, p))
4304               {
4305                 (*_bfd_error_handler)
4306                   (_("%B: section `%A' can't be allocated in segment %d"),
4307                    abfd, sec, j);
4308                 bfd_set_error (bfd_error_bad_value);
4309                 return FALSE;
4310               }
4311           }
4312     }
4313
4314   elf_tdata (abfd)->next_file_pos = off;
4315   return TRUE;
4316 }
4317
4318 /* Assign file positions for the other sections.  */
4319
4320 static bfd_boolean
4321 assign_file_positions_for_non_load_sections (bfd *abfd,
4322                                              struct bfd_link_info *link_info)
4323 {
4324   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4325   Elf_Internal_Shdr **i_shdrpp;
4326   Elf_Internal_Shdr **hdrpp;
4327   Elf_Internal_Phdr *phdrs;
4328   Elf_Internal_Phdr *p;
4329   struct elf_segment_map *m;
4330   bfd_vma filehdr_vaddr, filehdr_paddr;
4331   bfd_vma phdrs_vaddr, phdrs_paddr;
4332   file_ptr off;
4333   unsigned int num_sec;
4334   unsigned int i;
4335   unsigned int count;
4336
4337   i_shdrpp = elf_elfsections (abfd);
4338   num_sec = elf_numsections (abfd);
4339   off = elf_tdata (abfd)->next_file_pos;
4340   for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4341     {
4342       struct elf_obj_tdata *tdata = elf_tdata (abfd);
4343       Elf_Internal_Shdr *hdr;
4344
4345       hdr = *hdrpp;
4346       if (hdr->bfd_section != NULL
4347           && (hdr->bfd_section->filepos != 0
4348               || (hdr->sh_type == SHT_NOBITS
4349                   && hdr->contents == NULL)))
4350         BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4351       else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4352         {
4353           if (hdr->sh_size != 0)
4354             ((*_bfd_error_handler)
4355              (_("%B: warning: allocated section `%s' not in segment"),
4356               abfd,
4357               (hdr->bfd_section == NULL
4358                ? "*unknown*"
4359                : hdr->bfd_section->name)));
4360           /* We don't need to page align empty sections.  */
4361           if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4362             off += vma_page_aligned_bias (hdr->sh_addr, off,
4363                                           bed->maxpagesize);
4364           else
4365             off += vma_page_aligned_bias (hdr->sh_addr, off,
4366                                           hdr->sh_addralign);
4367           off = _bfd_elf_assign_file_position_for_section (hdr, off,
4368                                                            FALSE);
4369         }
4370       else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4371                 && hdr->bfd_section == NULL)
4372                || hdr == i_shdrpp[tdata->symtab_section]
4373                || hdr == i_shdrpp[tdata->symtab_shndx_section]
4374                || hdr == i_shdrpp[tdata->strtab_section])
4375         hdr->sh_offset = -1;
4376       else
4377         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4378
4379       if (i == SHN_LORESERVE - 1)
4380         {
4381           i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4382           hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4383         }
4384     }
4385
4386   /* Now that we have set the section file positions, we can set up
4387      the file positions for the non PT_LOAD segments.  */
4388   count = 0;
4389   filehdr_vaddr = 0;
4390   filehdr_paddr = 0;
4391   phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4392   phdrs_paddr = 0;
4393   phdrs = elf_tdata (abfd)->phdr;
4394   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4395        m != NULL;
4396        m = m->next, p++)
4397     {
4398       ++count;
4399       if (p->p_type != PT_LOAD)
4400         continue;
4401
4402       if (m->includes_filehdr)
4403         {
4404           filehdr_vaddr = p->p_vaddr;
4405           filehdr_paddr = p->p_paddr;
4406         }
4407       if (m->includes_phdrs)
4408         {
4409           phdrs_vaddr = p->p_vaddr;
4410           phdrs_paddr = p->p_paddr;
4411           if (m->includes_filehdr)
4412             {
4413               phdrs_vaddr += bed->s->sizeof_ehdr;
4414               phdrs_paddr += bed->s->sizeof_ehdr;
4415             }
4416         }
4417     }
4418
4419   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4420        m != NULL;
4421        m = m->next, p++)
4422     {
4423       if (m->count != 0)
4424         {
4425           if (p->p_type != PT_LOAD
4426               && (p->p_type != PT_NOTE || bfd_get_format (abfd) != bfd_core))
4427             {
4428               Elf_Internal_Shdr *hdr;
4429               BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4430
4431               hdr = &elf_section_data (m->sections[m->count - 1])->this_hdr;
4432               p->p_filesz = (m->sections[m->count - 1]->filepos
4433                              - m->sections[0]->filepos);
4434               if (hdr->sh_type != SHT_NOBITS)
4435                 p->p_filesz += hdr->sh_size;
4436
4437               p->p_offset = m->sections[0]->filepos;
4438             }
4439         }
4440       else
4441         {
4442           if (m->includes_filehdr)
4443             {
4444               p->p_vaddr = filehdr_vaddr;
4445               if (! m->p_paddr_valid)
4446                 p->p_paddr = filehdr_paddr;
4447             }
4448           else if (m->includes_phdrs)
4449             {
4450               p->p_vaddr = phdrs_vaddr;
4451               if (! m->p_paddr_valid)
4452                 p->p_paddr = phdrs_paddr;
4453             }
4454           else if (p->p_type == PT_GNU_RELRO)
4455             {
4456               Elf_Internal_Phdr *lp;
4457
4458               for (lp = phdrs; lp < phdrs + count; ++lp)
4459                 {
4460                   if (lp->p_type == PT_LOAD
4461                       && lp->p_vaddr <= link_info->relro_end
4462                       && lp->p_vaddr >= link_info->relro_start
4463                       && (lp->p_vaddr + lp->p_filesz
4464                           >= link_info->relro_end))
4465                     break;
4466                 }
4467
4468               if (lp < phdrs + count
4469                   && link_info->relro_end > lp->p_vaddr)
4470                 {
4471                   p->p_vaddr = lp->p_vaddr;
4472                   p->p_paddr = lp->p_paddr;
4473                   p->p_offset = lp->p_offset;
4474                   p->p_filesz = link_info->relro_end - lp->p_vaddr;
4475                   p->p_memsz = p->p_filesz;
4476                   p->p_align = 1;
4477                   p->p_flags = (lp->p_flags & ~PF_W);
4478                 }
4479               else
4480                 {
4481                   memset (p, 0, sizeof *p);
4482                   p->p_type = PT_NULL;
4483                 }
4484             }
4485         }
4486     }
4487
4488   elf_tdata (abfd)->next_file_pos = off;
4489
4490   return TRUE;
4491 }
4492
4493 /* Work out the file positions of all the sections.  This is called by
4494    _bfd_elf_compute_section_file_positions.  All the section sizes and
4495    VMAs must be known before this is called.
4496
4497    Reloc sections come in two flavours: Those processed specially as
4498    "side-channel" data attached to a section to which they apply, and
4499    those that bfd doesn't process as relocations.  The latter sort are
4500    stored in a normal bfd section by bfd_section_from_shdr.   We don't
4501    consider the former sort here, unless they form part of the loadable
4502    image.  Reloc sections not assigned here will be handled later by
4503    assign_file_positions_for_relocs.
4504
4505    We also don't set the positions of the .symtab and .strtab here.  */
4506
4507 static bfd_boolean
4508 assign_file_positions_except_relocs (bfd *abfd,
4509                                      struct bfd_link_info *link_info)
4510 {
4511   struct elf_obj_tdata *tdata = elf_tdata (abfd);
4512   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4513   file_ptr off;
4514   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4515
4516   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4517       && bfd_get_format (abfd) != bfd_core)
4518     {
4519       Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4520       unsigned int num_sec = elf_numsections (abfd);
4521       Elf_Internal_Shdr **hdrpp;
4522       unsigned int i;
4523
4524       /* Start after the ELF header.  */
4525       off = i_ehdrp->e_ehsize;
4526
4527       /* We are not creating an executable, which means that we are
4528          not creating a program header, and that the actual order of
4529          the sections in the file is unimportant.  */
4530       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4531         {
4532           Elf_Internal_Shdr *hdr;
4533
4534           hdr = *hdrpp;
4535           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4536                && hdr->bfd_section == NULL)
4537               || i == tdata->symtab_section
4538               || i == tdata->symtab_shndx_section
4539               || i == tdata->strtab_section)
4540             {
4541               hdr->sh_offset = -1;
4542             }
4543           else
4544             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4545
4546           if (i == SHN_LORESERVE - 1)
4547             {
4548               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4549               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4550             }
4551         }
4552     }
4553   else
4554     {
4555       unsigned int alloc;
4556
4557       /* Assign file positions for the loaded sections based on the
4558          assignment of sections to segments.  */
4559       if (!assign_file_positions_for_load_sections (abfd, link_info))
4560         return FALSE;
4561
4562       /* And for non-load sections.  */
4563       if (!assign_file_positions_for_non_load_sections (abfd, link_info))
4564         return FALSE;
4565
4566       if (bed->elf_backend_modify_program_headers != NULL)
4567         {
4568           if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
4569             return FALSE;
4570         }
4571
4572       /* Write out the program headers.  */
4573       alloc = tdata->program_header_size / bed->s->sizeof_phdr;
4574       if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4575           || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
4576         return FALSE;
4577
4578       off = tdata->next_file_pos;
4579     }
4580
4581   /* Place the section headers.  */
4582   off = align_file_position (off, 1 << bed->s->log_file_align);
4583   i_ehdrp->e_shoff = off;
4584   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4585
4586   tdata->next_file_pos = off;
4587
4588   return TRUE;
4589 }
4590
4591 static bfd_boolean
4592 prep_headers (bfd *abfd)
4593 {
4594   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
4595   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4596   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
4597   struct elf_strtab_hash *shstrtab;
4598   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4599
4600   i_ehdrp = elf_elfheader (abfd);
4601   i_shdrp = elf_elfsections (abfd);
4602
4603   shstrtab = _bfd_elf_strtab_init ();
4604   if (shstrtab == NULL)
4605     return FALSE;
4606
4607   elf_shstrtab (abfd) = shstrtab;
4608
4609   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4610   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4611   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4612   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4613
4614   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4615   i_ehdrp->e_ident[EI_DATA] =
4616     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4617   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4618
4619   if ((abfd->flags & DYNAMIC) != 0)
4620     i_ehdrp->e_type = ET_DYN;
4621   else if ((abfd->flags & EXEC_P) != 0)
4622     i_ehdrp->e_type = ET_EXEC;
4623   else if (bfd_get_format (abfd) == bfd_core)
4624     i_ehdrp->e_type = ET_CORE;
4625   else
4626     i_ehdrp->e_type = ET_REL;
4627
4628   switch (bfd_get_arch (abfd))
4629     {
4630     case bfd_arch_unknown:
4631       i_ehdrp->e_machine = EM_NONE;
4632       break;
4633
4634       /* There used to be a long list of cases here, each one setting
4635          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4636          in the corresponding bfd definition.  To avoid duplication,
4637          the switch was removed.  Machines that need special handling
4638          can generally do it in elf_backend_final_write_processing(),
4639          unless they need the information earlier than the final write.
4640          Such need can generally be supplied by replacing the tests for
4641          e_machine with the conditions used to determine it.  */
4642     default:
4643       i_ehdrp->e_machine = bed->elf_machine_code;
4644     }
4645
4646   i_ehdrp->e_version = bed->s->ev_current;
4647   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4648
4649   /* No program header, for now.  */
4650   i_ehdrp->e_phoff = 0;
4651   i_ehdrp->e_phentsize = 0;
4652   i_ehdrp->e_phnum = 0;
4653
4654   /* Each bfd section is section header entry.  */
4655   i_ehdrp->e_entry = bfd_get_start_address (abfd);
4656   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4657
4658   /* If we're building an executable, we'll need a program header table.  */
4659   if (abfd->flags & EXEC_P)
4660     /* It all happens later.  */
4661     ;
4662   else
4663     {
4664       i_ehdrp->e_phentsize = 0;
4665       i_phdrp = 0;
4666       i_ehdrp->e_phoff = 0;
4667     }
4668
4669   elf_tdata (abfd)->symtab_hdr.sh_name =
4670     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4671   elf_tdata (abfd)->strtab_hdr.sh_name =
4672     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4673   elf_tdata (abfd)->shstrtab_hdr.sh_name =
4674     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4675   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4676       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4677       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4678     return FALSE;
4679
4680   return TRUE;
4681 }
4682
4683 /* Assign file positions for all the reloc sections which are not part
4684    of the loadable file image.  */
4685
4686 void
4687 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4688 {
4689   file_ptr off;
4690   unsigned int i, num_sec;
4691   Elf_Internal_Shdr **shdrpp;
4692
4693   off = elf_tdata (abfd)->next_file_pos;
4694
4695   num_sec = elf_numsections (abfd);
4696   for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4697     {
4698       Elf_Internal_Shdr *shdrp;
4699
4700       shdrp = *shdrpp;
4701       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4702           && shdrp->sh_offset == -1)
4703         off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4704     }
4705
4706   elf_tdata (abfd)->next_file_pos = off;
4707 }
4708
4709 bfd_boolean
4710 _bfd_elf_write_object_contents (bfd *abfd)
4711 {
4712   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4713   Elf_Internal_Ehdr *i_ehdrp;
4714   Elf_Internal_Shdr **i_shdrp;
4715   bfd_boolean failed;
4716   unsigned int count, num_sec;
4717
4718   if (! abfd->output_has_begun
4719       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4720     return FALSE;
4721
4722   i_shdrp = elf_elfsections (abfd);
4723   i_ehdrp = elf_elfheader (abfd);
4724
4725   failed = FALSE;
4726   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4727   if (failed)
4728     return FALSE;
4729
4730   _bfd_elf_assign_file_positions_for_relocs (abfd);
4731
4732   /* After writing the headers, we need to write the sections too...  */
4733   num_sec = elf_numsections (abfd);
4734   for (count = 1; count < num_sec; count++)
4735     {
4736       if (bed->elf_backend_section_processing)
4737         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4738       if (i_shdrp[count]->contents)
4739         {
4740           bfd_size_type amt = i_shdrp[count]->sh_size;
4741
4742           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4743               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4744             return FALSE;
4745         }
4746       if (count == SHN_LORESERVE - 1)
4747         count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4748     }
4749
4750   /* Write out the section header names.  */
4751   if (elf_shstrtab (abfd) != NULL
4752       && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4753           || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
4754     return FALSE;
4755
4756   if (bed->elf_backend_final_write_processing)
4757     (*bed->elf_backend_final_write_processing) (abfd,
4758                                                 elf_tdata (abfd)->linker);
4759
4760   if (!bed->s->write_shdrs_and_ehdr (abfd))
4761     return FALSE;
4762
4763   /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0].  */
4764   if (elf_tdata (abfd)->after_write_object_contents)
4765     return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
4766
4767   return TRUE;
4768 }
4769
4770 bfd_boolean
4771 _bfd_elf_write_corefile_contents (bfd *abfd)
4772 {
4773   /* Hopefully this can be done just like an object file.  */
4774   return _bfd_elf_write_object_contents (abfd);
4775 }
4776
4777 /* Given a section, search the header to find them.  */
4778
4779 int
4780 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
4781 {
4782   const struct elf_backend_data *bed;
4783   int index;
4784
4785   if (elf_section_data (asect) != NULL
4786       && elf_section_data (asect)->this_idx != 0)
4787     return elf_section_data (asect)->this_idx;
4788
4789   if (bfd_is_abs_section (asect))
4790     index = SHN_ABS;
4791   else if (bfd_is_com_section (asect))
4792     index = SHN_COMMON;
4793   else if (bfd_is_und_section (asect))
4794     index = SHN_UNDEF;
4795   else
4796     index = -1;
4797
4798   bed = get_elf_backend_data (abfd);
4799   if (bed->elf_backend_section_from_bfd_section)
4800     {
4801       int retval = index;
4802
4803       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4804         return retval;
4805     }
4806
4807   if (index == -1)
4808     bfd_set_error (bfd_error_nonrepresentable_section);
4809
4810   return index;
4811 }
4812
4813 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4814    on error.  */
4815
4816 int
4817 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
4818 {
4819   asymbol *asym_ptr = *asym_ptr_ptr;
4820   int idx;
4821   flagword flags = asym_ptr->flags;
4822
4823   /* When gas creates relocations against local labels, it creates its
4824      own symbol for the section, but does put the symbol into the
4825      symbol chain, so udata is 0.  When the linker is generating
4826      relocatable output, this section symbol may be for one of the
4827      input sections rather than the output section.  */
4828   if (asym_ptr->udata.i == 0
4829       && (flags & BSF_SECTION_SYM)
4830       && asym_ptr->section)
4831     {
4832       asection *sec;
4833       int indx;
4834
4835       sec = asym_ptr->section;
4836       if (sec->owner != abfd && sec->output_section != NULL)
4837         sec = sec->output_section;
4838       if (sec->owner == abfd
4839           && (indx = sec->index) < elf_num_section_syms (abfd)
4840           && elf_section_syms (abfd)[indx] != NULL)
4841         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4842     }
4843
4844   idx = asym_ptr->udata.i;
4845
4846   if (idx == 0)
4847     {
4848       /* This case can occur when using --strip-symbol on a symbol
4849          which is used in a relocation entry.  */
4850       (*_bfd_error_handler)
4851         (_("%B: symbol `%s' required but not present"),
4852          abfd, bfd_asymbol_name (asym_ptr));
4853       bfd_set_error (bfd_error_no_symbols);
4854       return -1;
4855     }
4856
4857 #if DEBUG & 4
4858   {
4859     fprintf (stderr,
4860              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4861              (long) asym_ptr, asym_ptr->name, idx, flags,
4862              elf_symbol_flags (flags));
4863     fflush (stderr);
4864   }
4865 #endif
4866
4867   return idx;
4868 }
4869
4870 /* Rewrite program header information.  */
4871
4872 static bfd_boolean
4873 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
4874 {
4875   Elf_Internal_Ehdr *iehdr;
4876   struct elf_segment_map *map;
4877   struct elf_segment_map *map_first;
4878   struct elf_segment_map **pointer_to_map;
4879   Elf_Internal_Phdr *segment;
4880   asection *section;
4881   unsigned int i;
4882   unsigned int num_segments;
4883   bfd_boolean phdr_included = FALSE;
4884   bfd_vma maxpagesize;
4885   struct elf_segment_map *phdr_adjust_seg = NULL;
4886   unsigned int phdr_adjust_num = 0;
4887   const struct elf_backend_data *bed;
4888
4889   bed = get_elf_backend_data (ibfd);
4890   iehdr = elf_elfheader (ibfd);
4891
4892   map_first = NULL;
4893   pointer_to_map = &map_first;
4894
4895   num_segments = elf_elfheader (ibfd)->e_phnum;
4896   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4897
4898   /* Returns the end address of the segment + 1.  */
4899 #define SEGMENT_END(segment, start)                                     \
4900   (start + (segment->p_memsz > segment->p_filesz                        \
4901             ? segment->p_memsz : segment->p_filesz))
4902
4903 #define SECTION_SIZE(section, segment)                                  \
4904   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
4905     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
4906    ? section->size : 0)
4907
4908   /* Returns TRUE if the given section is contained within
4909      the given segment.  VMA addresses are compared.  */
4910 #define IS_CONTAINED_BY_VMA(section, segment)                           \
4911   (section->vma >= segment->p_vaddr                                     \
4912    && (section->vma + SECTION_SIZE (section, segment)                   \
4913        <= (SEGMENT_END (segment, segment->p_vaddr))))
4914
4915   /* Returns TRUE if the given section is contained within
4916      the given segment.  LMA addresses are compared.  */
4917 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
4918   (section->lma >= base                                                 \
4919    && (section->lma + SECTION_SIZE (section, segment)                   \
4920        <= SEGMENT_END (segment, base)))
4921
4922   /* Special case: corefile "NOTE" section containing regs, prpsinfo etc.  */
4923 #define IS_COREFILE_NOTE(p, s)                                          \
4924   (p->p_type == PT_NOTE                                                 \
4925    && bfd_get_format (ibfd) == bfd_core                                 \
4926    && s->vma == 0 && s->lma == 0                                        \
4927    && (bfd_vma) s->filepos >= p->p_offset                               \
4928    && ((bfd_vma) s->filepos + s->size                                   \
4929        <= p->p_offset + p->p_filesz))
4930
4931   /* The complicated case when p_vaddr is 0 is to handle the Solaris
4932      linker, which generates a PT_INTERP section with p_vaddr and
4933      p_memsz set to 0.  */
4934 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
4935   (p->p_vaddr == 0                                                      \
4936    && p->p_paddr == 0                                                   \
4937    && p->p_memsz == 0                                                   \
4938    && p->p_filesz > 0                                                   \
4939    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
4940    && s->size > 0                                                       \
4941    && (bfd_vma) s->filepos >= p->p_offset                               \
4942    && ((bfd_vma) s->filepos + s->size                                   \
4943        <= p->p_offset + p->p_filesz))
4944
4945   /* Decide if the given section should be included in the given segment.
4946      A section will be included if:
4947        1. It is within the address space of the segment -- we use the LMA
4948           if that is set for the segment and the VMA otherwise,
4949        2. It is an allocated segment,
4950        3. There is an output section associated with it,
4951        4. The section has not already been allocated to a previous segment.
4952        5. PT_GNU_STACK segments do not include any sections.
4953        6. PT_TLS segment includes only SHF_TLS sections.
4954        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
4955        8. PT_DYNAMIC should not contain empty sections at the beginning
4956           (with the possible exception of .dynamic).  */
4957 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed)              \
4958   ((((segment->p_paddr                                                  \
4959       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
4960       : IS_CONTAINED_BY_VMA (section, segment))                         \
4961      && (section->flags & SEC_ALLOC) != 0)                              \
4962     || IS_COREFILE_NOTE (segment, section))                             \
4963    && segment->p_type != PT_GNU_STACK                                   \
4964    && (segment->p_type != PT_TLS                                        \
4965        || (section->flags & SEC_THREAD_LOCAL))                          \
4966    && (segment->p_type == PT_LOAD                                       \
4967        || segment->p_type == PT_TLS                                     \
4968        || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
4969    && (segment->p_type != PT_DYNAMIC                                    \
4970        || SECTION_SIZE (section, segment) > 0                           \
4971        || (segment->p_paddr                                             \
4972            ? segment->p_paddr != section->lma                           \
4973            : segment->p_vaddr != section->vma)                          \
4974        || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic")    \
4975            == 0))                                                       \
4976    && ! section->segment_mark)
4977
4978 /* If the output section of a section in the input segment is NULL,
4979    it is removed from the corresponding output segment.   */
4980 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
4981   (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed)          \
4982    && section->output_section != NULL)
4983
4984   /* Returns TRUE iff seg1 starts after the end of seg2.  */
4985 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
4986   (seg1->field >= SEGMENT_END (seg2, seg2->field))
4987
4988   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
4989      their VMA address ranges and their LMA address ranges overlap.
4990      It is possible to have overlapping VMA ranges without overlapping LMA
4991      ranges.  RedBoot images for example can have both .data and .bss mapped
4992      to the same VMA range, but with the .data section mapped to a different
4993      LMA.  */
4994 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
4995   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
4996         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
4997    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
4998         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
4999
5000   /* Initialise the segment mark field.  */
5001   for (section = ibfd->sections; section != NULL; section = section->next)
5002     section->segment_mark = FALSE;
5003
5004   /* Scan through the segments specified in the program header
5005      of the input BFD.  For this first scan we look for overlaps
5006      in the loadable segments.  These can be created by weird
5007      parameters to objcopy.  Also, fix some solaris weirdness.  */
5008   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5009        i < num_segments;
5010        i++, segment++)
5011     {
5012       unsigned int j;
5013       Elf_Internal_Phdr *segment2;
5014
5015       if (segment->p_type == PT_INTERP)
5016         for (section = ibfd->sections; section; section = section->next)
5017           if (IS_SOLARIS_PT_INTERP (segment, section))
5018             {
5019               /* Mininal change so that the normal section to segment
5020                  assignment code will work.  */
5021               segment->p_vaddr = section->vma;
5022               break;
5023             }
5024
5025       if (segment->p_type != PT_LOAD)
5026         continue;
5027
5028       /* Determine if this segment overlaps any previous segments.  */
5029       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
5030         {
5031           bfd_signed_vma extra_length;
5032
5033           if (segment2->p_type != PT_LOAD
5034               || ! SEGMENT_OVERLAPS (segment, segment2))
5035             continue;
5036
5037           /* Merge the two segments together.  */
5038           if (segment2->p_vaddr < segment->p_vaddr)
5039             {
5040               /* Extend SEGMENT2 to include SEGMENT and then delete
5041                  SEGMENT.  */
5042               extra_length =
5043                 SEGMENT_END (segment, segment->p_vaddr)
5044                 - SEGMENT_END (segment2, segment2->p_vaddr);
5045
5046               if (extra_length > 0)
5047                 {
5048                   segment2->p_memsz  += extra_length;
5049                   segment2->p_filesz += extra_length;
5050                 }
5051
5052               segment->p_type = PT_NULL;
5053
5054               /* Since we have deleted P we must restart the outer loop.  */
5055               i = 0;
5056               segment = elf_tdata (ibfd)->phdr;
5057               break;
5058             }
5059           else
5060             {
5061               /* Extend SEGMENT to include SEGMENT2 and then delete
5062                  SEGMENT2.  */
5063               extra_length =
5064                 SEGMENT_END (segment2, segment2->p_vaddr)
5065                 - SEGMENT_END (segment, segment->p_vaddr);
5066
5067               if (extra_length > 0)
5068                 {
5069                   segment->p_memsz  += extra_length;
5070                   segment->p_filesz += extra_length;
5071                 }
5072
5073               segment2->p_type = PT_NULL;
5074             }
5075         }
5076     }
5077
5078   /* The second scan attempts to assign sections to segments.  */
5079   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5080        i < num_segments;
5081        i ++, segment ++)
5082     {
5083       unsigned int  section_count;
5084       asection **   sections;
5085       asection *    output_section;
5086       unsigned int  isec;
5087       bfd_vma       matching_lma;
5088       bfd_vma       suggested_lma;
5089       unsigned int  j;
5090       bfd_size_type amt;
5091       asection *    first_section;
5092
5093       if (segment->p_type == PT_NULL)
5094         continue;
5095
5096       first_section = NULL;
5097       /* Compute how many sections might be placed into this segment.  */
5098       for (section = ibfd->sections, section_count = 0;
5099            section != NULL;
5100            section = section->next)
5101         {
5102           /* Find the first section in the input segment, which may be
5103              removed from the corresponding output segment.   */
5104           if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5105             {
5106               if (first_section == NULL)
5107                 first_section = section;
5108               if (section->output_section != NULL)
5109                 ++section_count;
5110             }
5111         }
5112
5113       /* Allocate a segment map big enough to contain
5114          all of the sections we have selected.  */
5115       amt = sizeof (struct elf_segment_map);
5116       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5117       map = bfd_zalloc (obfd, amt);
5118       if (map == NULL)
5119         return FALSE;
5120
5121       /* Initialise the fields of the segment map.  Default to
5122          using the physical address of the segment in the input BFD.  */
5123       map->next          = NULL;
5124       map->p_type        = segment->p_type;
5125       map->p_flags       = segment->p_flags;
5126       map->p_flags_valid = 1;
5127
5128       /* If the first section in the input segment is removed, there is
5129          no need to preserve segment physical address in the corresponding
5130          output segment.  */
5131       if (!first_section || first_section->output_section != NULL)
5132         {
5133           map->p_paddr = segment->p_paddr;
5134           map->p_paddr_valid = 1;
5135         }
5136
5137       /* Determine if this segment contains the ELF file header
5138          and if it contains the program headers themselves.  */
5139       map->includes_filehdr = (segment->p_offset == 0
5140                                && segment->p_filesz >= iehdr->e_ehsize);
5141
5142       map->includes_phdrs = 0;
5143
5144       if (! phdr_included || segment->p_type != PT_LOAD)
5145         {
5146           map->includes_phdrs =
5147             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5148              && (segment->p_offset + segment->p_filesz
5149                  >= ((bfd_vma) iehdr->e_phoff
5150                      + iehdr->e_phnum * iehdr->e_phentsize)));
5151
5152           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5153             phdr_included = TRUE;
5154         }
5155
5156       if (section_count == 0)
5157         {
5158           /* Special segments, such as the PT_PHDR segment, may contain
5159              no sections, but ordinary, loadable segments should contain
5160              something.  They are allowed by the ELF spec however, so only
5161              a warning is produced.  */
5162           if (segment->p_type == PT_LOAD)
5163             (*_bfd_error_handler)
5164               (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5165                ibfd);
5166
5167           map->count = 0;
5168           *pointer_to_map = map;
5169           pointer_to_map = &map->next;
5170
5171           continue;
5172         }
5173
5174       /* Now scan the sections in the input BFD again and attempt
5175          to add their corresponding output sections to the segment map.
5176          The problem here is how to handle an output section which has
5177          been moved (ie had its LMA changed).  There are four possibilities:
5178
5179          1. None of the sections have been moved.
5180             In this case we can continue to use the segment LMA from the
5181             input BFD.
5182
5183          2. All of the sections have been moved by the same amount.
5184             In this case we can change the segment's LMA to match the LMA
5185             of the first section.
5186
5187          3. Some of the sections have been moved, others have not.
5188             In this case those sections which have not been moved can be
5189             placed in the current segment which will have to have its size,
5190             and possibly its LMA changed, and a new segment or segments will
5191             have to be created to contain the other sections.
5192
5193          4. The sections have been moved, but not by the same amount.
5194             In this case we can change the segment's LMA to match the LMA
5195             of the first section and we will have to create a new segment
5196             or segments to contain the other sections.
5197
5198          In order to save time, we allocate an array to hold the section
5199          pointers that we are interested in.  As these sections get assigned
5200          to a segment, they are removed from this array.  */
5201
5202       /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5203          to work around this long long bug.  */
5204       sections = bfd_malloc2 (section_count, sizeof (asection *));
5205       if (sections == NULL)
5206         return FALSE;
5207
5208       /* Step One: Scan for segment vs section LMA conflicts.
5209          Also add the sections to the section array allocated above.
5210          Also add the sections to the current segment.  In the common
5211          case, where the sections have not been moved, this means that
5212          we have completely filled the segment, and there is nothing
5213          more to do.  */
5214       isec = 0;
5215       matching_lma = 0;
5216       suggested_lma = 0;
5217
5218       for (j = 0, section = ibfd->sections;
5219            section != NULL;
5220            section = section->next)
5221         {
5222           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5223             {
5224               output_section = section->output_section;
5225
5226               sections[j ++] = section;
5227
5228               /* The Solaris native linker always sets p_paddr to 0.
5229                  We try to catch that case here, and set it to the
5230                  correct value.  Note - some backends require that
5231                  p_paddr be left as zero.  */
5232               if (segment->p_paddr == 0
5233                   && segment->p_vaddr != 0
5234                   && (! bed->want_p_paddr_set_to_zero)
5235                   && isec == 0
5236                   && output_section->lma != 0
5237                   && (output_section->vma == (segment->p_vaddr
5238                                               + (map->includes_filehdr
5239                                                  ? iehdr->e_ehsize
5240                                                  : 0)
5241                                               + (map->includes_phdrs
5242                                                  ? (iehdr->e_phnum
5243                                                     * iehdr->e_phentsize)
5244                                                  : 0))))
5245                 map->p_paddr = segment->p_vaddr;
5246
5247               /* Match up the physical address of the segment with the
5248                  LMA address of the output section.  */
5249               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5250                   || IS_COREFILE_NOTE (segment, section)
5251                   || (bed->want_p_paddr_set_to_zero &&
5252                       IS_CONTAINED_BY_VMA (output_section, segment)))
5253                 {
5254                   if (matching_lma == 0)
5255                     matching_lma = output_section->lma;
5256
5257                   /* We assume that if the section fits within the segment
5258                      then it does not overlap any other section within that
5259                      segment.  */
5260                   map->sections[isec ++] = output_section;
5261                 }
5262               else if (suggested_lma == 0)
5263                 suggested_lma = output_section->lma;
5264             }
5265         }
5266
5267       BFD_ASSERT (j == section_count);
5268
5269       /* Step Two: Adjust the physical address of the current segment,
5270          if necessary.  */
5271       if (isec == section_count)
5272         {
5273           /* All of the sections fitted within the segment as currently
5274              specified.  This is the default case.  Add the segment to
5275              the list of built segments and carry on to process the next
5276              program header in the input BFD.  */
5277           map->count = section_count;
5278           *pointer_to_map = map;
5279           pointer_to_map = &map->next;
5280
5281           if (matching_lma != map->p_paddr
5282               && !map->includes_filehdr && !map->includes_phdrs)
5283             /* There is some padding before the first section in the
5284                segment.  So, we must account for that in the output
5285                segment's vma.  */
5286             map->p_vaddr_offset = matching_lma - map->p_paddr;
5287
5288           free (sections);
5289           continue;
5290         }
5291       else
5292         {
5293           if (matching_lma != 0)
5294             {
5295               /* At least one section fits inside the current segment.
5296                  Keep it, but modify its physical address to match the
5297                  LMA of the first section that fitted.  */
5298               map->p_paddr = matching_lma;
5299             }
5300           else
5301             {
5302               /* None of the sections fitted inside the current segment.
5303                  Change the current segment's physical address to match
5304                  the LMA of the first section.  */
5305               map->p_paddr = suggested_lma;
5306             }
5307
5308           /* Offset the segment physical address from the lma
5309              to allow for space taken up by elf headers.  */
5310           if (map->includes_filehdr)
5311             map->p_paddr -= iehdr->e_ehsize;
5312
5313           if (map->includes_phdrs)
5314             {
5315               map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5316
5317               /* iehdr->e_phnum is just an estimate of the number
5318                  of program headers that we will need.  Make a note
5319                  here of the number we used and the segment we chose
5320                  to hold these headers, so that we can adjust the
5321                  offset when we know the correct value.  */
5322               phdr_adjust_num = iehdr->e_phnum;
5323               phdr_adjust_seg = map;
5324             }
5325         }
5326
5327       /* Step Three: Loop over the sections again, this time assigning
5328          those that fit to the current segment and removing them from the
5329          sections array; but making sure not to leave large gaps.  Once all
5330          possible sections have been assigned to the current segment it is
5331          added to the list of built segments and if sections still remain
5332          to be assigned, a new segment is constructed before repeating
5333          the loop.  */
5334       isec = 0;
5335       do
5336         {
5337           map->count = 0;
5338           suggested_lma = 0;
5339
5340           /* Fill the current segment with sections that fit.  */
5341           for (j = 0; j < section_count; j++)
5342             {
5343               section = sections[j];
5344
5345               if (section == NULL)
5346                 continue;
5347
5348               output_section = section->output_section;
5349
5350               BFD_ASSERT (output_section != NULL);
5351
5352               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5353                   || IS_COREFILE_NOTE (segment, section))
5354                 {
5355                   if (map->count == 0)
5356                     {
5357                       /* If the first section in a segment does not start at
5358                          the beginning of the segment, then something is
5359                          wrong.  */
5360                       if (output_section->lma !=
5361                           (map->p_paddr
5362                            + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5363                            + (map->includes_phdrs
5364                               ? iehdr->e_phnum * iehdr->e_phentsize
5365                               : 0)))
5366                         abort ();
5367                     }
5368                   else
5369                     {
5370                       asection * prev_sec;
5371
5372                       prev_sec = map->sections[map->count - 1];
5373
5374                       /* If the gap between the end of the previous section
5375                          and the start of this section is more than
5376                          maxpagesize then we need to start a new segment.  */
5377                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5378                                       maxpagesize)
5379                            < BFD_ALIGN (output_section->lma, maxpagesize))
5380                           || ((prev_sec->lma + prev_sec->size)
5381                               > output_section->lma))
5382                         {
5383                           if (suggested_lma == 0)
5384                             suggested_lma = output_section->lma;
5385
5386                           continue;
5387                         }
5388                     }
5389
5390                   map->sections[map->count++] = output_section;
5391                   ++isec;
5392                   sections[j] = NULL;
5393                   section->segment_mark = TRUE;
5394                 }
5395               else if (suggested_lma == 0)
5396                 suggested_lma = output_section->lma;
5397             }
5398
5399           BFD_ASSERT (map->count > 0);
5400
5401           /* Add the current segment to the list of built segments.  */
5402           *pointer_to_map = map;
5403           pointer_to_map = &map->next;
5404
5405           if (isec < section_count)
5406             {
5407               /* We still have not allocated all of the sections to
5408                  segments.  Create a new segment here, initialise it
5409                  and carry on looping.  */
5410               amt = sizeof (struct elf_segment_map);
5411               amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5412               map = bfd_alloc (obfd, amt);
5413               if (map == NULL)
5414                 {
5415                   free (sections);
5416                   return FALSE;
5417                 }
5418
5419               /* Initialise the fields of the segment map.  Set the physical
5420                  physical address to the LMA of the first section that has
5421                  not yet been assigned.  */
5422               map->next             = NULL;
5423               map->p_type           = segment->p_type;
5424               map->p_flags          = segment->p_flags;
5425               map->p_flags_valid    = 1;
5426               map->p_paddr          = suggested_lma;
5427               map->p_paddr_valid    = 1;
5428               map->includes_filehdr = 0;
5429               map->includes_phdrs   = 0;
5430             }
5431         }
5432       while (isec < section_count);
5433
5434       free (sections);
5435     }
5436
5437   /* The Solaris linker creates program headers in which all the
5438      p_paddr fields are zero.  When we try to objcopy or strip such a
5439      file, we get confused.  Check for this case, and if we find it
5440      reset the p_paddr_valid fields.  */
5441   for (map = map_first; map != NULL; map = map->next)
5442     if (map->p_paddr != 0)
5443       break;
5444   if (map == NULL)
5445     for (map = map_first; map != NULL; map = map->next)
5446       map->p_paddr_valid = 0;
5447
5448   elf_tdata (obfd)->segment_map = map_first;
5449
5450   /* If we had to estimate the number of program headers that were
5451      going to be needed, then check our estimate now and adjust
5452      the offset if necessary.  */
5453   if (phdr_adjust_seg != NULL)
5454     {
5455       unsigned int count;
5456
5457       for (count = 0, map = map_first; map != NULL; map = map->next)
5458         count++;
5459
5460       if (count > phdr_adjust_num)
5461         phdr_adjust_seg->p_paddr
5462           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5463     }
5464
5465 #undef SEGMENT_END
5466 #undef SECTION_SIZE
5467 #undef IS_CONTAINED_BY_VMA
5468 #undef IS_CONTAINED_BY_LMA
5469 #undef IS_COREFILE_NOTE
5470 #undef IS_SOLARIS_PT_INTERP
5471 #undef IS_SECTION_IN_INPUT_SEGMENT
5472 #undef INCLUDE_SECTION_IN_SEGMENT
5473 #undef SEGMENT_AFTER_SEGMENT
5474 #undef SEGMENT_OVERLAPS
5475   return TRUE;
5476 }
5477
5478 /* Copy ELF program header information.  */
5479
5480 static bfd_boolean
5481 copy_elf_program_header (bfd *ibfd, bfd *obfd)
5482 {
5483   Elf_Internal_Ehdr *iehdr;
5484   struct elf_segment_map *map;
5485   struct elf_segment_map *map_first;
5486   struct elf_segment_map **pointer_to_map;
5487   Elf_Internal_Phdr *segment;
5488   unsigned int i;
5489   unsigned int num_segments;
5490   bfd_boolean phdr_included = FALSE;
5491
5492   iehdr = elf_elfheader (ibfd);
5493
5494   map_first = NULL;
5495   pointer_to_map = &map_first;
5496
5497   num_segments = elf_elfheader (ibfd)->e_phnum;
5498   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5499        i < num_segments;
5500        i++, segment++)
5501     {
5502       asection *section;
5503       unsigned int section_count;
5504       bfd_size_type amt;
5505       Elf_Internal_Shdr *this_hdr;
5506       asection *first_section = NULL;
5507
5508       /* FIXME: Do we need to copy PT_NULL segment?  */
5509       if (segment->p_type == PT_NULL)
5510         continue;
5511
5512       /* Compute how many sections are in this segment.  */
5513       for (section = ibfd->sections, section_count = 0;
5514            section != NULL;
5515            section = section->next)
5516         {
5517           this_hdr = &(elf_section_data(section)->this_hdr);
5518           if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5519             {
5520               if (!first_section)
5521                 first_section = section;
5522               section_count++;
5523             }
5524         }
5525
5526       /* Allocate a segment map big enough to contain
5527          all of the sections we have selected.  */
5528       amt = sizeof (struct elf_segment_map);
5529       if (section_count != 0)
5530         amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5531       map = bfd_zalloc (obfd, amt);
5532       if (map == NULL)
5533         return FALSE;
5534
5535       /* Initialize the fields of the output segment map with the
5536          input segment.  */
5537       map->next = NULL;
5538       map->p_type = segment->p_type;
5539       map->p_flags = segment->p_flags;
5540       map->p_flags_valid = 1;
5541       map->p_paddr = segment->p_paddr;
5542       map->p_paddr_valid = 1;
5543       map->p_align = segment->p_align;
5544       map->p_align_valid = 1;
5545       map->p_vaddr_offset = 0;
5546
5547       /* Determine if this segment contains the ELF file header
5548          and if it contains the program headers themselves.  */
5549       map->includes_filehdr = (segment->p_offset == 0
5550                                && segment->p_filesz >= iehdr->e_ehsize);
5551
5552       map->includes_phdrs = 0;
5553       if (! phdr_included || segment->p_type != PT_LOAD)
5554         {
5555           map->includes_phdrs =
5556             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5557              && (segment->p_offset + segment->p_filesz
5558                  >= ((bfd_vma) iehdr->e_phoff
5559                      + iehdr->e_phnum * iehdr->e_phentsize)));
5560
5561           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5562             phdr_included = TRUE;
5563         }
5564
5565       if (!map->includes_phdrs && !map->includes_filehdr)
5566         /* There is some other padding before the first section.  */
5567         map->p_vaddr_offset = ((first_section ? first_section->lma : 0)
5568                                - segment->p_paddr);
5569
5570       if (section_count != 0)
5571         {
5572           unsigned int isec = 0;
5573
5574           for (section = first_section;
5575                section != NULL;
5576                section = section->next)
5577             {
5578               this_hdr = &(elf_section_data(section)->this_hdr);
5579               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5580                 {
5581                   map->sections[isec++] = section->output_section;
5582                   if (isec == section_count)
5583                     break;
5584                 }
5585             }
5586         }
5587
5588       map->count = section_count;
5589       *pointer_to_map = map;
5590       pointer_to_map = &map->next;
5591     }
5592
5593   elf_tdata (obfd)->segment_map = map_first;
5594   return TRUE;
5595 }
5596
5597 /* Copy private BFD data.  This copies or rewrites ELF program header
5598    information.  */
5599
5600 static bfd_boolean
5601 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5602 {
5603   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5604       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5605     return TRUE;
5606
5607   if (elf_tdata (ibfd)->phdr == NULL)
5608     return TRUE;
5609
5610   if (ibfd->xvec == obfd->xvec)
5611     {
5612       /* Check to see if any sections in the input BFD
5613          covered by ELF program header have changed.  */
5614       Elf_Internal_Phdr *segment;
5615       asection *section, *osec;
5616       unsigned int i, num_segments;
5617       Elf_Internal_Shdr *this_hdr;
5618
5619       /* Initialize the segment mark field.  */
5620       for (section = obfd->sections; section != NULL;
5621            section = section->next)
5622         section->segment_mark = FALSE;
5623
5624       num_segments = elf_elfheader (ibfd)->e_phnum;
5625       for (i = 0, segment = elf_tdata (ibfd)->phdr;
5626            i < num_segments;
5627            i++, segment++)
5628         {
5629           /* PR binutils/3535.  The Solaris linker always sets the p_paddr
5630              and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5631              which severly confuses things, so always regenerate the segment
5632              map in this case.  */
5633           if (segment->p_paddr == 0
5634               && segment->p_memsz == 0
5635               && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
5636             goto rewrite;
5637
5638           for (section = ibfd->sections;
5639                section != NULL; section = section->next)
5640             {
5641               /* We mark the output section so that we know it comes
5642                  from the input BFD.  */
5643               osec = section->output_section;
5644               if (osec)
5645                 osec->segment_mark = TRUE;
5646
5647               /* Check if this section is covered by the segment.  */
5648               this_hdr = &(elf_section_data(section)->this_hdr);
5649               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5650                 {
5651                   /* FIXME: Check if its output section is changed or
5652                      removed.  What else do we need to check?  */
5653                   if (osec == NULL
5654                       || section->flags != osec->flags
5655                       || section->lma != osec->lma
5656                       || section->vma != osec->vma
5657                       || section->size != osec->size
5658                       || section->rawsize != osec->rawsize
5659                       || section->alignment_power != osec->alignment_power)
5660                     goto rewrite;
5661                 }
5662             }
5663         }
5664
5665       /* Check to see if any output section do not come from the
5666          input BFD.  */
5667       for (section = obfd->sections; section != NULL;
5668            section = section->next)
5669         {
5670           if (section->segment_mark == FALSE)
5671             goto rewrite;
5672           else
5673             section->segment_mark = FALSE;
5674         }
5675
5676       return copy_elf_program_header (ibfd, obfd);
5677     }
5678
5679 rewrite:
5680   return rewrite_elf_program_header (ibfd, obfd);
5681 }
5682
5683 /* Initialize private output section information from input section.  */
5684
5685 bfd_boolean
5686 _bfd_elf_init_private_section_data (bfd *ibfd,
5687                                     asection *isec,
5688                                     bfd *obfd,
5689                                     asection *osec,
5690                                     struct bfd_link_info *link_info)
5691
5692 {
5693   Elf_Internal_Shdr *ihdr, *ohdr;
5694   bfd_boolean need_group = link_info == NULL || link_info->relocatable;
5695
5696   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5697       || obfd->xvec->flavour != bfd_target_elf_flavour)
5698     return TRUE;
5699
5700   /* Don't copy the output ELF section type from input if the
5701      output BFD section flags have been set to something different.
5702      elf_fake_sections will set ELF section type based on BFD
5703      section flags.  */
5704   if (elf_section_type (osec) == SHT_NULL
5705       && (osec->flags == isec->flags || !osec->flags))
5706     elf_section_type (osec) = elf_section_type (isec);
5707
5708   /* FIXME: Is this correct for all OS/PROC specific flags?  */
5709   elf_section_flags (osec) |= (elf_section_flags (isec)
5710                                & (SHF_MASKOS | SHF_MASKPROC));
5711
5712   /* Set things up for objcopy and relocatable link.  The output
5713      SHT_GROUP section will have its elf_next_in_group pointing back
5714      to the input group members.  Ignore linker created group section.
5715      See elfNN_ia64_object_p in elfxx-ia64.c.  */
5716   if (need_group)
5717     {
5718       if (elf_sec_group (isec) == NULL
5719           || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
5720         {
5721           if (elf_section_flags (isec) & SHF_GROUP)
5722             elf_section_flags (osec) |= SHF_GROUP;
5723           elf_next_in_group (osec) = elf_next_in_group (isec);
5724           elf_group_name (osec) = elf_group_name (isec);
5725         }
5726     }
5727
5728   ihdr = &elf_section_data (isec)->this_hdr;
5729
5730   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
5731      don't use the output section of the linked-to section since it
5732      may be NULL at this point.  */
5733   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
5734     {
5735       ohdr = &elf_section_data (osec)->this_hdr;
5736       ohdr->sh_flags |= SHF_LINK_ORDER;
5737       elf_linked_to_section (osec) = elf_linked_to_section (isec);
5738     }
5739
5740   osec->use_rela_p = isec->use_rela_p;
5741
5742   return TRUE;
5743 }
5744
5745 /* Copy private section information.  This copies over the entsize
5746    field, and sometimes the info field.  */
5747
5748 bfd_boolean
5749 _bfd_elf_copy_private_section_data (bfd *ibfd,
5750                                     asection *isec,
5751                                     bfd *obfd,
5752                                     asection *osec)
5753 {
5754   Elf_Internal_Shdr *ihdr, *ohdr;
5755
5756   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5757       || obfd->xvec->flavour != bfd_target_elf_flavour)
5758     return TRUE;
5759
5760   ihdr = &elf_section_data (isec)->this_hdr;
5761   ohdr = &elf_section_data (osec)->this_hdr;
5762
5763   ohdr->sh_entsize = ihdr->sh_entsize;
5764
5765   if (ihdr->sh_type == SHT_SYMTAB
5766       || ihdr->sh_type == SHT_DYNSYM
5767       || ihdr->sh_type == SHT_GNU_verneed
5768       || ihdr->sh_type == SHT_GNU_verdef)
5769     ohdr->sh_info = ihdr->sh_info;
5770
5771   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
5772                                              NULL);
5773 }
5774
5775 /* Copy private header information.  */
5776
5777 bfd_boolean
5778 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
5779 {
5780   asection *isec;
5781
5782   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5783       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5784     return TRUE;
5785
5786   /* Copy over private BFD data if it has not already been copied.
5787      This must be done here, rather than in the copy_private_bfd_data
5788      entry point, because the latter is called after the section
5789      contents have been set, which means that the program headers have
5790      already been worked out.  */
5791   if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5792     {
5793       if (! copy_private_bfd_data (ibfd, obfd))
5794         return FALSE;
5795     }
5796
5797   /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
5798      but this might be wrong if we deleted the group section.  */
5799   for (isec = ibfd->sections; isec != NULL; isec = isec->next)
5800     if (elf_section_type (isec) == SHT_GROUP
5801         && isec->output_section == NULL)
5802       {
5803         asection *first = elf_next_in_group (isec);
5804         asection *s = first;
5805         while (s != NULL)
5806           {
5807             if (s->output_section != NULL)
5808               {
5809                 elf_section_flags (s->output_section) &= ~SHF_GROUP;
5810                 elf_group_name (s->output_section) = NULL;
5811               }
5812             s = elf_next_in_group (s);
5813             if (s == first)
5814               break;
5815           }
5816       }
5817
5818   return TRUE;
5819 }
5820
5821 /* Copy private symbol information.  If this symbol is in a section
5822    which we did not map into a BFD section, try to map the section
5823    index correctly.  We use special macro definitions for the mapped
5824    section indices; these definitions are interpreted by the
5825    swap_out_syms function.  */
5826
5827 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5828 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5829 #define MAP_STRTAB    (SHN_HIOS + 3)
5830 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
5831 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5832
5833 bfd_boolean
5834 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
5835                                    asymbol *isymarg,
5836                                    bfd *obfd,
5837                                    asymbol *osymarg)
5838 {
5839   elf_symbol_type *isym, *osym;
5840
5841   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5842       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5843     return TRUE;
5844
5845   isym = elf_symbol_from (ibfd, isymarg);
5846   osym = elf_symbol_from (obfd, osymarg);
5847
5848   if (isym != NULL
5849       && osym != NULL
5850       && bfd_is_abs_section (isym->symbol.section))
5851     {
5852       unsigned int shndx;
5853
5854       shndx = isym->internal_elf_sym.st_shndx;
5855       if (shndx == elf_onesymtab (ibfd))
5856         shndx = MAP_ONESYMTAB;
5857       else if (shndx == elf_dynsymtab (ibfd))
5858         shndx = MAP_DYNSYMTAB;
5859       else if (shndx == elf_tdata (ibfd)->strtab_section)
5860         shndx = MAP_STRTAB;
5861       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5862         shndx = MAP_SHSTRTAB;
5863       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5864         shndx = MAP_SYM_SHNDX;
5865       osym->internal_elf_sym.st_shndx = shndx;
5866     }
5867
5868   return TRUE;
5869 }
5870
5871 /* Swap out the symbols.  */
5872
5873 static bfd_boolean
5874 swap_out_syms (bfd *abfd,
5875                struct bfd_strtab_hash **sttp,
5876                int relocatable_p)
5877 {
5878   const struct elf_backend_data *bed;
5879   int symcount;
5880   asymbol **syms;
5881   struct bfd_strtab_hash *stt;
5882   Elf_Internal_Shdr *symtab_hdr;
5883   Elf_Internal_Shdr *symtab_shndx_hdr;
5884   Elf_Internal_Shdr *symstrtab_hdr;
5885   bfd_byte *outbound_syms;
5886   bfd_byte *outbound_shndx;
5887   int idx;
5888   bfd_size_type amt;
5889   bfd_boolean name_local_sections;
5890
5891   if (!elf_map_symbols (abfd))
5892     return FALSE;
5893
5894   /* Dump out the symtabs.  */
5895   stt = _bfd_elf_stringtab_init ();
5896   if (stt == NULL)
5897     return FALSE;
5898
5899   bed = get_elf_backend_data (abfd);
5900   symcount = bfd_get_symcount (abfd);
5901   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5902   symtab_hdr->sh_type = SHT_SYMTAB;
5903   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5904   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5905   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5906   symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
5907
5908   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5909   symstrtab_hdr->sh_type = SHT_STRTAB;
5910
5911   outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
5912   if (outbound_syms == NULL)
5913     {
5914       _bfd_stringtab_free (stt);
5915       return FALSE;
5916     }
5917   symtab_hdr->contents = outbound_syms;
5918
5919   outbound_shndx = NULL;
5920   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5921   if (symtab_shndx_hdr->sh_name != 0)
5922     {
5923       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5924       outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
5925                                     sizeof (Elf_External_Sym_Shndx));
5926       if (outbound_shndx == NULL)
5927         {
5928           _bfd_stringtab_free (stt);
5929           return FALSE;
5930         }
5931
5932       symtab_shndx_hdr->contents = outbound_shndx;
5933       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5934       symtab_shndx_hdr->sh_size = amt;
5935       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5936       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5937     }
5938
5939   /* Now generate the data (for "contents").  */
5940   {
5941     /* Fill in zeroth symbol and swap it out.  */
5942     Elf_Internal_Sym sym;
5943     sym.st_name = 0;
5944     sym.st_value = 0;
5945     sym.st_size = 0;
5946     sym.st_info = 0;
5947     sym.st_other = 0;
5948     sym.st_shndx = SHN_UNDEF;
5949     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5950     outbound_syms += bed->s->sizeof_sym;
5951     if (outbound_shndx != NULL)
5952       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5953   }
5954
5955   name_local_sections
5956     = (bed->elf_backend_name_local_section_symbols
5957        && bed->elf_backend_name_local_section_symbols (abfd));
5958
5959   syms = bfd_get_outsymbols (abfd);
5960   for (idx = 0; idx < symcount; idx++)
5961     {
5962       Elf_Internal_Sym sym;
5963       bfd_vma value = syms[idx]->value;
5964       elf_symbol_type *type_ptr;
5965       flagword flags = syms[idx]->flags;
5966       int type;
5967
5968       if (!name_local_sections
5969           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5970         {
5971           /* Local section symbols have no name.  */
5972           sym.st_name = 0;
5973         }
5974       else
5975         {
5976           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5977                                                             syms[idx]->name,
5978                                                             TRUE, FALSE);
5979           if (sym.st_name == (unsigned long) -1)
5980             {
5981               _bfd_stringtab_free (stt);
5982               return FALSE;
5983             }
5984         }
5985
5986       type_ptr = elf_symbol_from (abfd, syms[idx]);
5987
5988       if ((flags & BSF_SECTION_SYM) == 0
5989           && bfd_is_com_section (syms[idx]->section))
5990         {
5991           /* ELF common symbols put the alignment into the `value' field,
5992              and the size into the `size' field.  This is backwards from
5993              how BFD handles it, so reverse it here.  */
5994           sym.st_size = value;
5995           if (type_ptr == NULL
5996               || type_ptr->internal_elf_sym.st_value == 0)
5997             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5998           else
5999             sym.st_value = type_ptr->internal_elf_sym.st_value;
6000           sym.st_shndx = _bfd_elf_section_from_bfd_section
6001             (abfd, syms[idx]->section);
6002         }
6003       else
6004         {
6005           asection *sec = syms[idx]->section;
6006           int shndx;
6007
6008           if (sec->output_section)
6009             {
6010               value += sec->output_offset;
6011               sec = sec->output_section;
6012             }
6013
6014           /* Don't add in the section vma for relocatable output.  */
6015           if (! relocatable_p)
6016             value += sec->vma;
6017           sym.st_value = value;
6018           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6019
6020           if (bfd_is_abs_section (sec)
6021               && type_ptr != NULL
6022               && type_ptr->internal_elf_sym.st_shndx != 0)
6023             {
6024               /* This symbol is in a real ELF section which we did
6025                  not create as a BFD section.  Undo the mapping done
6026                  by copy_private_symbol_data.  */
6027               shndx = type_ptr->internal_elf_sym.st_shndx;
6028               switch (shndx)
6029                 {
6030                 case MAP_ONESYMTAB:
6031                   shndx = elf_onesymtab (abfd);
6032                   break;
6033                 case MAP_DYNSYMTAB:
6034                   shndx = elf_dynsymtab (abfd);
6035                   break;
6036                 case MAP_STRTAB:
6037                   shndx = elf_tdata (abfd)->strtab_section;
6038                   break;
6039                 case MAP_SHSTRTAB:
6040                   shndx = elf_tdata (abfd)->shstrtab_section;
6041                   break;
6042                 case MAP_SYM_SHNDX:
6043                   shndx = elf_tdata (abfd)->symtab_shndx_section;
6044                   break;
6045                 default:
6046                   break;
6047                 }
6048             }
6049           else
6050             {
6051               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6052
6053               if (shndx == -1)
6054                 {
6055                   asection *sec2;
6056
6057                   /* Writing this would be a hell of a lot easier if
6058                      we had some decent documentation on bfd, and
6059                      knew what to expect of the library, and what to
6060                      demand of applications.  For example, it
6061                      appears that `objcopy' might not set the
6062                      section of a symbol to be a section that is
6063                      actually in the output file.  */
6064                   sec2 = bfd_get_section_by_name (abfd, sec->name);
6065                   if (sec2 == NULL)
6066                     {
6067                       _bfd_error_handler (_("\
6068 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6069                                           syms[idx]->name ? syms[idx]->name : "<Local sym>",
6070                                           sec->name);
6071                       bfd_set_error (bfd_error_invalid_operation);
6072                       _bfd_stringtab_free (stt);
6073                       return FALSE;
6074                     }
6075
6076                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6077                   BFD_ASSERT (shndx != -1);
6078                 }
6079             }
6080
6081           sym.st_shndx = shndx;
6082         }
6083
6084       if ((flags & BSF_THREAD_LOCAL) != 0)
6085         type = STT_TLS;
6086       else if ((flags & BSF_FUNCTION) != 0)
6087         type = STT_FUNC;
6088       else if ((flags & BSF_OBJECT) != 0)
6089         type = STT_OBJECT;
6090       else if ((flags & BSF_RELC) != 0)
6091         type = STT_RELC;
6092       else if ((flags & BSF_SRELC) != 0)
6093         type = STT_SRELC;
6094       else
6095         type = STT_NOTYPE;
6096
6097       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6098         type = STT_TLS;
6099
6100       /* Processor-specific types.  */
6101       if (type_ptr != NULL
6102           && bed->elf_backend_get_symbol_type)
6103         type = ((*bed->elf_backend_get_symbol_type)
6104                 (&type_ptr->internal_elf_sym, type));
6105
6106       if (flags & BSF_SECTION_SYM)
6107         {
6108           if (flags & BSF_GLOBAL)
6109             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6110           else
6111             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6112         }
6113       else if (bfd_is_com_section (syms[idx]->section))
6114         sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6115       else if (bfd_is_und_section (syms[idx]->section))
6116         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6117                                     ? STB_WEAK
6118                                     : STB_GLOBAL),
6119                                    type);
6120       else if (flags & BSF_FILE)
6121         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6122       else
6123         {
6124           int bind = STB_LOCAL;
6125
6126           if (flags & BSF_LOCAL)
6127             bind = STB_LOCAL;
6128           else if (flags & BSF_WEAK)
6129             bind = STB_WEAK;
6130           else if (flags & BSF_GLOBAL)
6131             bind = STB_GLOBAL;
6132
6133           sym.st_info = ELF_ST_INFO (bind, type);
6134         }
6135
6136       if (type_ptr != NULL)
6137         sym.st_other = type_ptr->internal_elf_sym.st_other;
6138       else
6139         sym.st_other = 0;
6140
6141       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6142       outbound_syms += bed->s->sizeof_sym;
6143       if (outbound_shndx != NULL)
6144         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6145     }
6146
6147   *sttp = stt;
6148   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6149   symstrtab_hdr->sh_type = SHT_STRTAB;
6150
6151   symstrtab_hdr->sh_flags = 0;
6152   symstrtab_hdr->sh_addr = 0;
6153   symstrtab_hdr->sh_entsize = 0;
6154   symstrtab_hdr->sh_link = 0;
6155   symstrtab_hdr->sh_info = 0;
6156   symstrtab_hdr->sh_addralign = 1;
6157
6158   return TRUE;
6159 }
6160
6161 /* Return the number of bytes required to hold the symtab vector.
6162
6163    Note that we base it on the count plus 1, since we will null terminate
6164    the vector allocated based on this size.  However, the ELF symbol table
6165    always has a dummy entry as symbol #0, so it ends up even.  */
6166
6167 long
6168 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6169 {
6170   long symcount;
6171   long symtab_size;
6172   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6173
6174   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6175   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6176   if (symcount > 0)
6177     symtab_size -= sizeof (asymbol *);
6178
6179   return symtab_size;
6180 }
6181
6182 long
6183 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6184 {
6185   long symcount;
6186   long symtab_size;
6187   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6188
6189   if (elf_dynsymtab (abfd) == 0)
6190     {
6191       bfd_set_error (bfd_error_invalid_operation);
6192       return -1;
6193     }
6194
6195   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6196   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6197   if (symcount > 0)
6198     symtab_size -= sizeof (asymbol *);
6199
6200   return symtab_size;
6201 }
6202
6203 long
6204 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6205                                 sec_ptr asect)
6206 {
6207   return (asect->reloc_count + 1) * sizeof (arelent *);
6208 }
6209
6210 /* Canonicalize the relocs.  */
6211
6212 long
6213 _bfd_elf_canonicalize_reloc (bfd *abfd,
6214                              sec_ptr section,
6215                              arelent **relptr,
6216                              asymbol **symbols)
6217 {
6218   arelent *tblptr;
6219   unsigned int i;
6220   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6221
6222   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6223     return -1;
6224
6225   tblptr = section->relocation;
6226   for (i = 0; i < section->reloc_count; i++)
6227     *relptr++ = tblptr++;
6228
6229   *relptr = NULL;
6230
6231   return section->reloc_count;
6232 }
6233
6234 long
6235 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6236 {
6237   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6238   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6239
6240   if (symcount >= 0)
6241     bfd_get_symcount (abfd) = symcount;
6242   return symcount;
6243 }
6244
6245 long
6246 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6247                                       asymbol **allocation)
6248 {
6249   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6250   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6251
6252   if (symcount >= 0)
6253     bfd_get_dynamic_symcount (abfd) = symcount;
6254   return symcount;
6255 }
6256
6257 /* Return the size required for the dynamic reloc entries.  Any loadable
6258    section that was actually installed in the BFD, and has type SHT_REL
6259    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6260    dynamic reloc section.  */
6261
6262 long
6263 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6264 {
6265   long ret;
6266   asection *s;
6267
6268   if (elf_dynsymtab (abfd) == 0)
6269     {
6270       bfd_set_error (bfd_error_invalid_operation);
6271       return -1;
6272     }
6273
6274   ret = sizeof (arelent *);
6275   for (s = abfd->sections; s != NULL; s = s->next)
6276     if ((s->flags & SEC_LOAD) != 0
6277         && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6278         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6279             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6280       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6281               * sizeof (arelent *));
6282
6283   return ret;
6284 }
6285
6286 /* Canonicalize the dynamic relocation entries.  Note that we return the
6287    dynamic relocations as a single block, although they are actually
6288    associated with particular sections; the interface, which was
6289    designed for SunOS style shared libraries, expects that there is only
6290    one set of dynamic relocs.  Any loadable section that was actually
6291    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6292    dynamic symbol table, is considered to be a dynamic reloc section.  */
6293
6294 long
6295 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6296                                      arelent **storage,
6297                                      asymbol **syms)
6298 {
6299   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6300   asection *s;
6301   long ret;
6302
6303   if (elf_dynsymtab (abfd) == 0)
6304     {
6305       bfd_set_error (bfd_error_invalid_operation);
6306       return -1;
6307     }
6308
6309   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6310   ret = 0;
6311   for (s = abfd->sections; s != NULL; s = s->next)
6312     {
6313       if ((s->flags & SEC_LOAD) != 0
6314           && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6315           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6316               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6317         {
6318           arelent *p;
6319           long count, i;
6320
6321           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6322             return -1;
6323           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6324           p = s->relocation;
6325           for (i = 0; i < count; i++)
6326             *storage++ = p++;
6327           ret += count;
6328         }
6329     }
6330
6331   *storage = NULL;
6332
6333   return ret;
6334 }
6335 \f
6336 /* Read in the version information.  */
6337
6338 bfd_boolean
6339 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6340 {
6341   bfd_byte *contents = NULL;
6342   unsigned int freeidx = 0;
6343
6344   if (elf_dynverref (abfd) != 0)
6345     {
6346       Elf_Internal_Shdr *hdr;
6347       Elf_External_Verneed *everneed;
6348       Elf_Internal_Verneed *iverneed;
6349       unsigned int i;
6350       bfd_byte *contents_end;
6351
6352       hdr = &elf_tdata (abfd)->dynverref_hdr;
6353
6354       elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6355                                               sizeof (Elf_Internal_Verneed));
6356       if (elf_tdata (abfd)->verref == NULL)
6357         goto error_return;
6358
6359       elf_tdata (abfd)->cverrefs = hdr->sh_info;
6360
6361       contents = bfd_malloc (hdr->sh_size);
6362       if (contents == NULL)
6363         {
6364 error_return_verref:
6365           elf_tdata (abfd)->verref = NULL;
6366           elf_tdata (abfd)->cverrefs = 0;
6367           goto error_return;
6368         }
6369       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6370           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6371         goto error_return_verref;
6372
6373       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6374         goto error_return_verref;
6375
6376       BFD_ASSERT (sizeof (Elf_External_Verneed)
6377                   == sizeof (Elf_External_Vernaux));
6378       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6379       everneed = (Elf_External_Verneed *) contents;
6380       iverneed = elf_tdata (abfd)->verref;
6381       for (i = 0; i < hdr->sh_info; i++, iverneed++)
6382         {
6383           Elf_External_Vernaux *evernaux;
6384           Elf_Internal_Vernaux *ivernaux;
6385           unsigned int j;
6386
6387           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6388
6389           iverneed->vn_bfd = abfd;
6390
6391           iverneed->vn_filename =
6392             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6393                                              iverneed->vn_file);
6394           if (iverneed->vn_filename == NULL)
6395             goto error_return_verref;
6396
6397           if (iverneed->vn_cnt == 0)
6398             iverneed->vn_auxptr = NULL;
6399           else
6400             {
6401               iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6402                                                 sizeof (Elf_Internal_Vernaux));
6403               if (iverneed->vn_auxptr == NULL)
6404                 goto error_return_verref;
6405             }
6406
6407           if (iverneed->vn_aux
6408               > (size_t) (contents_end - (bfd_byte *) everneed))
6409             goto error_return_verref;
6410
6411           evernaux = ((Elf_External_Vernaux *)
6412                       ((bfd_byte *) everneed + iverneed->vn_aux));
6413           ivernaux = iverneed->vn_auxptr;
6414           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6415             {
6416               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6417
6418               ivernaux->vna_nodename =
6419                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6420                                                  ivernaux->vna_name);
6421               if (ivernaux->vna_nodename == NULL)
6422                 goto error_return_verref;
6423
6424               if (j + 1 < iverneed->vn_cnt)
6425                 ivernaux->vna_nextptr = ivernaux + 1;
6426               else
6427                 ivernaux->vna_nextptr = NULL;
6428
6429               if (ivernaux->vna_next
6430                   > (size_t) (contents_end - (bfd_byte *) evernaux))
6431                 goto error_return_verref;
6432
6433               evernaux = ((Elf_External_Vernaux *)
6434                           ((bfd_byte *) evernaux + ivernaux->vna_next));
6435
6436               if (ivernaux->vna_other > freeidx)
6437                 freeidx = ivernaux->vna_other;
6438             }
6439
6440           if (i + 1 < hdr->sh_info)
6441             iverneed->vn_nextref = iverneed + 1;
6442           else
6443             iverneed->vn_nextref = NULL;
6444
6445           if (iverneed->vn_next
6446               > (size_t) (contents_end - (bfd_byte *) everneed))
6447             goto error_return_verref;
6448
6449           everneed = ((Elf_External_Verneed *)
6450                       ((bfd_byte *) everneed + iverneed->vn_next));
6451         }
6452
6453       free (contents);
6454       contents = NULL;
6455     }
6456
6457   if (elf_dynverdef (abfd) != 0)
6458     {
6459       Elf_Internal_Shdr *hdr;
6460       Elf_External_Verdef *everdef;
6461       Elf_Internal_Verdef *iverdef;
6462       Elf_Internal_Verdef *iverdefarr;
6463       Elf_Internal_Verdef iverdefmem;
6464       unsigned int i;
6465       unsigned int maxidx;
6466       bfd_byte *contents_end_def, *contents_end_aux;
6467
6468       hdr = &elf_tdata (abfd)->dynverdef_hdr;
6469
6470       contents = bfd_malloc (hdr->sh_size);
6471       if (contents == NULL)
6472         goto error_return;
6473       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6474           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6475         goto error_return;
6476
6477       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6478         goto error_return;
6479
6480       BFD_ASSERT (sizeof (Elf_External_Verdef)
6481                   >= sizeof (Elf_External_Verdaux));
6482       contents_end_def = contents + hdr->sh_size
6483                          - sizeof (Elf_External_Verdef);
6484       contents_end_aux = contents + hdr->sh_size
6485                          - sizeof (Elf_External_Verdaux);
6486
6487       /* We know the number of entries in the section but not the maximum
6488          index.  Therefore we have to run through all entries and find
6489          the maximum.  */
6490       everdef = (Elf_External_Verdef *) contents;
6491       maxidx = 0;
6492       for (i = 0; i < hdr->sh_info; ++i)
6493         {
6494           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6495
6496           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6497             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6498
6499           if (iverdefmem.vd_next
6500               > (size_t) (contents_end_def - (bfd_byte *) everdef))
6501             goto error_return;
6502
6503           everdef = ((Elf_External_Verdef *)
6504                      ((bfd_byte *) everdef + iverdefmem.vd_next));
6505         }
6506
6507       if (default_imported_symver)
6508         {
6509           if (freeidx > maxidx)
6510             maxidx = ++freeidx;
6511           else
6512             freeidx = ++maxidx;
6513         }
6514       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6515                                               sizeof (Elf_Internal_Verdef));
6516       if (elf_tdata (abfd)->verdef == NULL)
6517         goto error_return;
6518
6519       elf_tdata (abfd)->cverdefs = maxidx;
6520
6521       everdef = (Elf_External_Verdef *) contents;
6522       iverdefarr = elf_tdata (abfd)->verdef;
6523       for (i = 0; i < hdr->sh_info; i++)
6524         {
6525           Elf_External_Verdaux *everdaux;
6526           Elf_Internal_Verdaux *iverdaux;
6527           unsigned int j;
6528
6529           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6530
6531           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6532             {
6533 error_return_verdef:
6534               elf_tdata (abfd)->verdef = NULL;
6535               elf_tdata (abfd)->cverdefs = 0;
6536               goto error_return;
6537             }
6538
6539           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6540           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6541
6542           iverdef->vd_bfd = abfd;
6543
6544           if (iverdef->vd_cnt == 0)
6545             iverdef->vd_auxptr = NULL;
6546           else
6547             {
6548               iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6549                                                sizeof (Elf_Internal_Verdaux));
6550               if (iverdef->vd_auxptr == NULL)
6551                 goto error_return_verdef;
6552             }
6553
6554           if (iverdef->vd_aux
6555               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6556             goto error_return_verdef;
6557
6558           everdaux = ((Elf_External_Verdaux *)
6559                       ((bfd_byte *) everdef + iverdef->vd_aux));
6560           iverdaux = iverdef->vd_auxptr;
6561           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6562             {
6563               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6564
6565               iverdaux->vda_nodename =
6566                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6567                                                  iverdaux->vda_name);
6568               if (iverdaux->vda_nodename == NULL)
6569                 goto error_return_verdef;
6570
6571               if (j + 1 < iverdef->vd_cnt)
6572                 iverdaux->vda_nextptr = iverdaux + 1;
6573               else
6574                 iverdaux->vda_nextptr = NULL;
6575
6576               if (iverdaux->vda_next
6577                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6578                 goto error_return_verdef;
6579
6580               everdaux = ((Elf_External_Verdaux *)
6581                           ((bfd_byte *) everdaux + iverdaux->vda_next));
6582             }
6583
6584           if (iverdef->vd_cnt)
6585             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6586
6587           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
6588             iverdef->vd_nextdef = iverdef + 1;
6589           else
6590             iverdef->vd_nextdef = NULL;
6591
6592           everdef = ((Elf_External_Verdef *)
6593                      ((bfd_byte *) everdef + iverdef->vd_next));
6594         }
6595
6596       free (contents);
6597       contents = NULL;
6598     }
6599   else if (default_imported_symver)
6600     {
6601       if (freeidx < 3)
6602         freeidx = 3;
6603       else
6604         freeidx++;
6605
6606       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6607                                               sizeof (Elf_Internal_Verdef));
6608       if (elf_tdata (abfd)->verdef == NULL)
6609         goto error_return;
6610
6611       elf_tdata (abfd)->cverdefs = freeidx;
6612     }
6613
6614   /* Create a default version based on the soname.  */
6615   if (default_imported_symver)
6616     {
6617       Elf_Internal_Verdef *iverdef;
6618       Elf_Internal_Verdaux *iverdaux;
6619
6620       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6621
6622       iverdef->vd_version = VER_DEF_CURRENT;
6623       iverdef->vd_flags = 0;
6624       iverdef->vd_ndx = freeidx;
6625       iverdef->vd_cnt = 1;
6626
6627       iverdef->vd_bfd = abfd;
6628
6629       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6630       if (iverdef->vd_nodename == NULL)
6631         goto error_return_verdef;
6632       iverdef->vd_nextdef = NULL;
6633       iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6634       if (iverdef->vd_auxptr == NULL)
6635         goto error_return_verdef;
6636
6637       iverdaux = iverdef->vd_auxptr;
6638       iverdaux->vda_nodename = iverdef->vd_nodename;
6639       iverdaux->vda_nextptr = NULL;
6640     }
6641
6642   return TRUE;
6643
6644  error_return:
6645   if (contents != NULL)
6646     free (contents);
6647   return FALSE;
6648 }
6649 \f
6650 asymbol *
6651 _bfd_elf_make_empty_symbol (bfd *abfd)
6652 {
6653   elf_symbol_type *newsym;
6654   bfd_size_type amt = sizeof (elf_symbol_type);
6655
6656   newsym = bfd_zalloc (abfd, amt);
6657   if (!newsym)
6658     return NULL;
6659   else
6660     {
6661       newsym->symbol.the_bfd = abfd;
6662       return &newsym->symbol;
6663     }
6664 }
6665
6666 void
6667 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6668                           asymbol *symbol,
6669                           symbol_info *ret)
6670 {
6671   bfd_symbol_info (symbol, ret);
6672 }
6673
6674 /* Return whether a symbol name implies a local symbol.  Most targets
6675    use this function for the is_local_label_name entry point, but some
6676    override it.  */
6677
6678 bfd_boolean
6679 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6680                               const char *name)
6681 {
6682   /* Normal local symbols start with ``.L''.  */
6683   if (name[0] == '.' && name[1] == 'L')
6684     return TRUE;
6685
6686   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6687      DWARF debugging symbols starting with ``..''.  */
6688   if (name[0] == '.' && name[1] == '.')
6689     return TRUE;
6690
6691   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6692      emitting DWARF debugging output.  I suspect this is actually a
6693      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6694      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6695      underscore to be emitted on some ELF targets).  For ease of use,
6696      we treat such symbols as local.  */
6697   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
6698     return TRUE;
6699
6700   return FALSE;
6701 }
6702
6703 alent *
6704 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6705                      asymbol *symbol ATTRIBUTE_UNUSED)
6706 {
6707   abort ();
6708   return NULL;
6709 }
6710
6711 bfd_boolean
6712 _bfd_elf_set_arch_mach (bfd *abfd,
6713                         enum bfd_architecture arch,
6714                         unsigned long machine)
6715 {
6716   /* If this isn't the right architecture for this backend, and this
6717      isn't the generic backend, fail.  */
6718   if (arch != get_elf_backend_data (abfd)->arch
6719       && arch != bfd_arch_unknown
6720       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
6721     return FALSE;
6722
6723   return bfd_default_set_arch_mach (abfd, arch, machine);
6724 }
6725
6726 /* Find the function to a particular section and offset,
6727    for error reporting.  */
6728
6729 static bfd_boolean
6730 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6731                    asection *section,
6732                    asymbol **symbols,
6733                    bfd_vma offset,
6734                    const char **filename_ptr,
6735                    const char **functionname_ptr)
6736 {
6737   const char *filename;
6738   asymbol *func, *file;
6739   bfd_vma low_func;
6740   asymbol **p;
6741   /* ??? Given multiple file symbols, it is impossible to reliably
6742      choose the right file name for global symbols.  File symbols are
6743      local symbols, and thus all file symbols must sort before any
6744      global symbols.  The ELF spec may be interpreted to say that a
6745      file symbol must sort before other local symbols, but currently
6746      ld -r doesn't do this.  So, for ld -r output, it is possible to
6747      make a better choice of file name for local symbols by ignoring
6748      file symbols appearing after a given local symbol.  */
6749   enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
6750
6751   filename = NULL;
6752   func = NULL;
6753   file = NULL;
6754   low_func = 0;
6755   state = nothing_seen;
6756
6757   for (p = symbols; *p != NULL; p++)
6758     {
6759       elf_symbol_type *q;
6760
6761       q = (elf_symbol_type *) *p;
6762
6763       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6764         {
6765         default:
6766           break;
6767         case STT_FILE:
6768           file = &q->symbol;
6769           if (state == symbol_seen)
6770             state = file_after_symbol_seen;
6771           continue;
6772         case STT_NOTYPE:
6773         case STT_FUNC:
6774           if (bfd_get_section (&q->symbol) == section
6775               && q->symbol.value >= low_func
6776               && q->symbol.value <= offset)
6777             {
6778               func = (asymbol *) q;
6779               low_func = q->symbol.value;
6780               filename = NULL;
6781               if (file != NULL
6782                   && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
6783                       || state != file_after_symbol_seen))
6784                 filename = bfd_asymbol_name (file);
6785             }
6786           break;
6787         }
6788       if (state == nothing_seen)
6789         state = symbol_seen;
6790     }
6791
6792   if (func == NULL)
6793     return FALSE;
6794
6795   if (filename_ptr)
6796     *filename_ptr = filename;
6797   if (functionname_ptr)
6798     *functionname_ptr = bfd_asymbol_name (func);
6799
6800   return TRUE;
6801 }
6802
6803 /* Find the nearest line to a particular section and offset,
6804    for error reporting.  */
6805
6806 bfd_boolean
6807 _bfd_elf_find_nearest_line (bfd *abfd,
6808                             asection *section,
6809                             asymbol **symbols,
6810                             bfd_vma offset,
6811                             const char **filename_ptr,
6812                             const char **functionname_ptr,
6813                             unsigned int *line_ptr)
6814 {
6815   bfd_boolean found;
6816
6817   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6818                                      filename_ptr, functionname_ptr,
6819                                      line_ptr))
6820     {
6821       if (!*functionname_ptr)
6822         elf_find_function (abfd, section, symbols, offset,
6823                            *filename_ptr ? NULL : filename_ptr,
6824                            functionname_ptr);
6825
6826       return TRUE;
6827     }
6828
6829   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6830                                      filename_ptr, functionname_ptr,
6831                                      line_ptr, 0,
6832                                      &elf_tdata (abfd)->dwarf2_find_line_info))
6833     {
6834       if (!*functionname_ptr)
6835         elf_find_function (abfd, section, symbols, offset,
6836                            *filename_ptr ? NULL : filename_ptr,
6837                            functionname_ptr);
6838
6839       return TRUE;
6840     }
6841
6842   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6843                                              &found, filename_ptr,
6844                                              functionname_ptr, line_ptr,
6845                                              &elf_tdata (abfd)->line_info))
6846     return FALSE;
6847   if (found && (*functionname_ptr || *line_ptr))
6848     return TRUE;
6849
6850   if (symbols == NULL)
6851     return FALSE;
6852
6853   if (! elf_find_function (abfd, section, symbols, offset,
6854                            filename_ptr, functionname_ptr))
6855     return FALSE;
6856
6857   *line_ptr = 0;
6858   return TRUE;
6859 }
6860
6861 /* Find the line for a symbol.  */
6862
6863 bfd_boolean
6864 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
6865                     const char **filename_ptr, unsigned int *line_ptr)
6866 {
6867   return _bfd_dwarf2_find_line (abfd, symbols, symbol,
6868                                 filename_ptr, line_ptr, 0,
6869                                 &elf_tdata (abfd)->dwarf2_find_line_info);
6870 }
6871
6872 /* After a call to bfd_find_nearest_line, successive calls to
6873    bfd_find_inliner_info can be used to get source information about
6874    each level of function inlining that terminated at the address
6875    passed to bfd_find_nearest_line.  Currently this is only supported
6876    for DWARF2 with appropriate DWARF3 extensions. */
6877
6878 bfd_boolean
6879 _bfd_elf_find_inliner_info (bfd *abfd,
6880                             const char **filename_ptr,
6881                             const char **functionname_ptr,
6882                             unsigned int *line_ptr)
6883 {
6884   bfd_boolean found;
6885   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
6886                                          functionname_ptr, line_ptr,
6887                                          & elf_tdata (abfd)->dwarf2_find_line_info);
6888   return found;
6889 }
6890
6891 int
6892 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
6893 {
6894   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6895   int ret = bed->s->sizeof_ehdr;
6896
6897   if (!info->relocatable)
6898     {
6899       bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
6900
6901       if (phdr_size == (bfd_size_type) -1)
6902         {
6903           struct elf_segment_map *m;
6904
6905           phdr_size = 0;
6906           for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
6907             phdr_size += bed->s->sizeof_phdr;
6908
6909           if (phdr_size == 0)
6910             phdr_size = get_program_header_size (abfd, info);
6911         }
6912
6913       elf_tdata (abfd)->program_header_size = phdr_size;
6914       ret += phdr_size;
6915     }
6916
6917   return ret;
6918 }
6919
6920 bfd_boolean
6921 _bfd_elf_set_section_contents (bfd *abfd,
6922                                sec_ptr section,
6923                                const void *location,
6924                                file_ptr offset,
6925                                bfd_size_type count)
6926 {
6927   Elf_Internal_Shdr *hdr;
6928   bfd_signed_vma pos;
6929
6930   if (! abfd->output_has_begun
6931       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6932     return FALSE;
6933
6934   hdr = &elf_section_data (section)->this_hdr;
6935   pos = hdr->sh_offset + offset;
6936   if (bfd_seek (abfd, pos, SEEK_SET) != 0
6937       || bfd_bwrite (location, count, abfd) != count)
6938     return FALSE;
6939
6940   return TRUE;
6941 }
6942
6943 void
6944 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
6945                            arelent *cache_ptr ATTRIBUTE_UNUSED,
6946                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
6947 {
6948   abort ();
6949 }
6950
6951 /* Try to convert a non-ELF reloc into an ELF one.  */
6952
6953 bfd_boolean
6954 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
6955 {
6956   /* Check whether we really have an ELF howto.  */
6957
6958   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6959     {
6960       bfd_reloc_code_real_type code;
6961       reloc_howto_type *howto;
6962
6963       /* Alien reloc: Try to determine its type to replace it with an
6964          equivalent ELF reloc.  */
6965
6966       if (areloc->howto->pc_relative)
6967         {
6968           switch (areloc->howto->bitsize)
6969             {
6970             case 8:
6971               code = BFD_RELOC_8_PCREL;
6972               break;
6973             case 12:
6974               code = BFD_RELOC_12_PCREL;
6975               break;
6976             case 16:
6977               code = BFD_RELOC_16_PCREL;
6978               break;
6979             case 24:
6980               code = BFD_RELOC_24_PCREL;
6981               break;
6982             case 32:
6983               code = BFD_RELOC_32_PCREL;
6984               break;
6985             case 64:
6986               code = BFD_RELOC_64_PCREL;
6987               break;
6988             default:
6989               goto fail;
6990             }
6991
6992           howto = bfd_reloc_type_lookup (abfd, code);
6993
6994           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6995             {
6996               if (howto->pcrel_offset)
6997                 areloc->addend += areloc->address;
6998               else
6999                 areloc->addend -= areloc->address; /* addend is unsigned!! */
7000             }
7001         }
7002       else
7003         {
7004           switch (areloc->howto->bitsize)
7005             {
7006             case 8:
7007               code = BFD_RELOC_8;
7008               break;
7009             case 14:
7010               code = BFD_RELOC_14;
7011               break;
7012             case 16:
7013               code = BFD_RELOC_16;
7014               break;
7015             case 26:
7016               code = BFD_RELOC_26;
7017               break;
7018             case 32:
7019               code = BFD_RELOC_32;
7020               break;
7021             case 64:
7022               code = BFD_RELOC_64;
7023               break;
7024             default:
7025               goto fail;
7026             }
7027
7028           howto = bfd_reloc_type_lookup (abfd, code);
7029         }
7030
7031       if (howto)
7032         areloc->howto = howto;
7033       else
7034         goto fail;
7035     }
7036
7037   return TRUE;
7038
7039  fail:
7040   (*_bfd_error_handler)
7041     (_("%B: unsupported relocation type %s"),
7042      abfd, areloc->howto->name);
7043   bfd_set_error (bfd_error_bad_value);
7044   return FALSE;
7045 }
7046
7047 bfd_boolean
7048 _bfd_elf_close_and_cleanup (bfd *abfd)
7049 {
7050   if (bfd_get_format (abfd) == bfd_object)
7051     {
7052       if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
7053         _bfd_elf_strtab_free (elf_shstrtab (abfd));
7054       _bfd_dwarf2_cleanup_debug_info (abfd);
7055     }
7056
7057   return _bfd_generic_close_and_cleanup (abfd);
7058 }
7059
7060 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7061    in the relocation's offset.  Thus we cannot allow any sort of sanity
7062    range-checking to interfere.  There is nothing else to do in processing
7063    this reloc.  */
7064
7065 bfd_reloc_status_type
7066 _bfd_elf_rel_vtable_reloc_fn
7067   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7068    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7069    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7070    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7071 {
7072   return bfd_reloc_ok;
7073 }
7074 \f
7075 /* Elf core file support.  Much of this only works on native
7076    toolchains, since we rely on knowing the
7077    machine-dependent procfs structure in order to pick
7078    out details about the corefile.  */
7079
7080 #ifdef HAVE_SYS_PROCFS_H
7081 # include <sys/procfs.h>
7082 #endif
7083
7084 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
7085
7086 static int
7087 elfcore_make_pid (bfd *abfd)
7088 {
7089   return ((elf_tdata (abfd)->core_lwpid << 16)
7090           + (elf_tdata (abfd)->core_pid));
7091 }
7092
7093 /* If there isn't a section called NAME, make one, using
7094    data from SECT.  Note, this function will generate a
7095    reference to NAME, so you shouldn't deallocate or
7096    overwrite it.  */
7097
7098 static bfd_boolean
7099 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7100 {
7101   asection *sect2;
7102
7103   if (bfd_get_section_by_name (abfd, name) != NULL)
7104     return TRUE;
7105
7106   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7107   if (sect2 == NULL)
7108     return FALSE;
7109
7110   sect2->size = sect->size;
7111   sect2->filepos = sect->filepos;
7112   sect2->alignment_power = sect->alignment_power;
7113   return TRUE;
7114 }
7115
7116 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
7117    actually creates up to two pseudosections:
7118    - For the single-threaded case, a section named NAME, unless
7119      such a section already exists.
7120    - For the multi-threaded case, a section named "NAME/PID", where
7121      PID is elfcore_make_pid (abfd).
7122    Both pseudosections have identical contents. */
7123 bfd_boolean
7124 _bfd_elfcore_make_pseudosection (bfd *abfd,
7125                                  char *name,
7126                                  size_t size,
7127                                  ufile_ptr filepos)
7128 {
7129   char buf[100];
7130   char *threaded_name;
7131   size_t len;
7132   asection *sect;
7133
7134   /* Build the section name.  */
7135
7136   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7137   len = strlen (buf) + 1;
7138   threaded_name = bfd_alloc (abfd, len);
7139   if (threaded_name == NULL)
7140     return FALSE;
7141   memcpy (threaded_name, buf, len);
7142
7143   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7144                                              SEC_HAS_CONTENTS);
7145   if (sect == NULL)
7146     return FALSE;
7147   sect->size = size;
7148   sect->filepos = filepos;
7149   sect->alignment_power = 2;
7150
7151   return elfcore_maybe_make_sect (abfd, name, sect);
7152 }
7153
7154 /* prstatus_t exists on:
7155      solaris 2.5+
7156      linux 2.[01] + glibc
7157      unixware 4.2
7158 */
7159
7160 #if defined (HAVE_PRSTATUS_T)
7161
7162 static bfd_boolean
7163 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7164 {
7165   size_t size;
7166   int offset;
7167
7168   if (note->descsz == sizeof (prstatus_t))
7169     {
7170       prstatus_t prstat;
7171
7172       size = sizeof (prstat.pr_reg);
7173       offset   = offsetof (prstatus_t, pr_reg);
7174       memcpy (&prstat, note->descdata, sizeof (prstat));
7175
7176       /* Do not overwrite the core signal if it
7177          has already been set by another thread.  */
7178       if (elf_tdata (abfd)->core_signal == 0)
7179         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7180       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7181
7182       /* pr_who exists on:
7183          solaris 2.5+
7184          unixware 4.2
7185          pr_who doesn't exist on:
7186          linux 2.[01]
7187          */
7188 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7189       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7190 #endif
7191     }
7192 #if defined (HAVE_PRSTATUS32_T)
7193   else if (note->descsz == sizeof (prstatus32_t))
7194     {
7195       /* 64-bit host, 32-bit corefile */
7196       prstatus32_t prstat;
7197
7198       size = sizeof (prstat.pr_reg);
7199       offset   = offsetof (prstatus32_t, pr_reg);
7200       memcpy (&prstat, note->descdata, sizeof (prstat));
7201
7202       /* Do not overwrite the core signal if it
7203          has already been set by another thread.  */
7204       if (elf_tdata (abfd)->core_signal == 0)
7205         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7206       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7207
7208       /* pr_who exists on:
7209          solaris 2.5+
7210          unixware 4.2
7211          pr_who doesn't exist on:
7212          linux 2.[01]
7213          */
7214 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7215       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7216 #endif
7217     }
7218 #endif /* HAVE_PRSTATUS32_T */
7219   else
7220     {
7221       /* Fail - we don't know how to handle any other
7222          note size (ie. data object type).  */
7223       return TRUE;
7224     }
7225
7226   /* Make a ".reg/999" section and a ".reg" section.  */
7227   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7228                                           size, note->descpos + offset);
7229 }
7230 #endif /* defined (HAVE_PRSTATUS_T) */
7231
7232 /* Create a pseudosection containing the exact contents of NOTE.  */
7233 static bfd_boolean
7234 elfcore_make_note_pseudosection (bfd *abfd,
7235                                  char *name,
7236                                  Elf_Internal_Note *note)
7237 {
7238   return _bfd_elfcore_make_pseudosection (abfd, name,
7239                                           note->descsz, note->descpos);
7240 }
7241
7242 /* There isn't a consistent prfpregset_t across platforms,
7243    but it doesn't matter, because we don't have to pick this
7244    data structure apart.  */
7245
7246 static bfd_boolean
7247 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7248 {
7249   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7250 }
7251
7252 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7253    type of 5 (NT_PRXFPREG).  Just include the whole note's contents
7254    literally.  */
7255
7256 static bfd_boolean
7257 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7258 {
7259   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7260 }
7261
7262 #if defined (HAVE_PRPSINFO_T)
7263 typedef prpsinfo_t   elfcore_psinfo_t;
7264 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
7265 typedef prpsinfo32_t elfcore_psinfo32_t;
7266 #endif
7267 #endif
7268
7269 #if defined (HAVE_PSINFO_T)
7270 typedef psinfo_t   elfcore_psinfo_t;
7271 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
7272 typedef psinfo32_t elfcore_psinfo32_t;
7273 #endif
7274 #endif
7275
7276 /* return a malloc'ed copy of a string at START which is at
7277    most MAX bytes long, possibly without a terminating '\0'.
7278    the copy will always have a terminating '\0'.  */
7279
7280 char *
7281 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7282 {
7283   char *dups;
7284   char *end = memchr (start, '\0', max);
7285   size_t len;
7286
7287   if (end == NULL)
7288     len = max;
7289   else
7290     len = end - start;
7291
7292   dups = bfd_alloc (abfd, len + 1);
7293   if (dups == NULL)
7294     return NULL;
7295
7296   memcpy (dups, start, len);
7297   dups[len] = '\0';
7298
7299   return dups;
7300 }
7301
7302 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7303 static bfd_boolean
7304 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7305 {
7306   if (note->descsz == sizeof (elfcore_psinfo_t))
7307     {
7308       elfcore_psinfo_t psinfo;
7309
7310       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7311
7312       elf_tdata (abfd)->core_program
7313         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7314                                 sizeof (psinfo.pr_fname));
7315
7316       elf_tdata (abfd)->core_command
7317         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7318                                 sizeof (psinfo.pr_psargs));
7319     }
7320 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7321   else if (note->descsz == sizeof (elfcore_psinfo32_t))
7322     {
7323       /* 64-bit host, 32-bit corefile */
7324       elfcore_psinfo32_t psinfo;
7325
7326       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7327
7328       elf_tdata (abfd)->core_program
7329         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7330                                 sizeof (psinfo.pr_fname));
7331
7332       elf_tdata (abfd)->core_command
7333         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7334                                 sizeof (psinfo.pr_psargs));
7335     }
7336 #endif
7337
7338   else
7339     {
7340       /* Fail - we don't know how to handle any other
7341          note size (ie. data object type).  */
7342       return TRUE;
7343     }
7344
7345   /* Note that for some reason, a spurious space is tacked
7346      onto the end of the args in some (at least one anyway)
7347      implementations, so strip it off if it exists.  */
7348
7349   {
7350     char *command = elf_tdata (abfd)->core_command;
7351     int n = strlen (command);
7352
7353     if (0 < n && command[n - 1] == ' ')
7354       command[n - 1] = '\0';
7355   }
7356
7357   return TRUE;
7358 }
7359 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7360
7361 #if defined (HAVE_PSTATUS_T)
7362 static bfd_boolean
7363 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7364 {
7365   if (note->descsz == sizeof (pstatus_t)
7366 #if defined (HAVE_PXSTATUS_T)
7367       || note->descsz == sizeof (pxstatus_t)
7368 #endif
7369       )
7370     {
7371       pstatus_t pstat;
7372
7373       memcpy (&pstat, note->descdata, sizeof (pstat));
7374
7375       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7376     }
7377 #if defined (HAVE_PSTATUS32_T)
7378   else if (note->descsz == sizeof (pstatus32_t))
7379     {
7380       /* 64-bit host, 32-bit corefile */
7381       pstatus32_t pstat;
7382
7383       memcpy (&pstat, note->descdata, sizeof (pstat));
7384
7385       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7386     }
7387 #endif
7388   /* Could grab some more details from the "representative"
7389      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7390      NT_LWPSTATUS note, presumably.  */
7391
7392   return TRUE;
7393 }
7394 #endif /* defined (HAVE_PSTATUS_T) */
7395
7396 #if defined (HAVE_LWPSTATUS_T)
7397 static bfd_boolean
7398 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7399 {
7400   lwpstatus_t lwpstat;
7401   char buf[100];
7402   char *name;
7403   size_t len;
7404   asection *sect;
7405
7406   if (note->descsz != sizeof (lwpstat)
7407 #if defined (HAVE_LWPXSTATUS_T)
7408       && note->descsz != sizeof (lwpxstatus_t)
7409 #endif
7410       )
7411     return TRUE;
7412
7413   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7414
7415   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7416   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7417
7418   /* Make a ".reg/999" section.  */
7419
7420   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7421   len = strlen (buf) + 1;
7422   name = bfd_alloc (abfd, len);
7423   if (name == NULL)
7424     return FALSE;
7425   memcpy (name, buf, len);
7426
7427   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7428   if (sect == NULL)
7429     return FALSE;
7430
7431 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7432   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7433   sect->filepos = note->descpos
7434     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7435 #endif
7436
7437 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7438   sect->size = sizeof (lwpstat.pr_reg);
7439   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7440 #endif
7441
7442   sect->alignment_power = 2;
7443
7444   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7445     return FALSE;
7446
7447   /* Make a ".reg2/999" section */
7448
7449   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7450   len = strlen (buf) + 1;
7451   name = bfd_alloc (abfd, len);
7452   if (name == NULL)
7453     return FALSE;
7454   memcpy (name, buf, len);
7455
7456   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7457   if (sect == NULL)
7458     return FALSE;
7459
7460 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7461   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7462   sect->filepos = note->descpos
7463     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7464 #endif
7465
7466 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7467   sect->size = sizeof (lwpstat.pr_fpreg);
7468   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7469 #endif
7470
7471   sect->alignment_power = 2;
7472
7473   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7474 }
7475 #endif /* defined (HAVE_LWPSTATUS_T) */
7476
7477 #if defined (HAVE_WIN32_PSTATUS_T)
7478 static bfd_boolean
7479 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7480 {
7481   char buf[30];
7482   char *name;
7483   size_t len;
7484   asection *sect;
7485   win32_pstatus_t pstatus;
7486
7487   if (note->descsz < sizeof (pstatus))
7488     return TRUE;
7489
7490   memcpy (&pstatus, note->descdata, sizeof (pstatus));
7491
7492   switch (pstatus.data_type)
7493     {
7494     case NOTE_INFO_PROCESS:
7495       /* FIXME: need to add ->core_command.  */
7496       elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7497       elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
7498       break;
7499
7500     case NOTE_INFO_THREAD:
7501       /* Make a ".reg/999" section.  */
7502       sprintf (buf, ".reg/%ld", (long) pstatus.data.thread_info.tid);
7503
7504       len = strlen (buf) + 1;
7505       name = bfd_alloc (abfd, len);
7506       if (name == NULL)
7507         return FALSE;
7508
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       sect->size = sizeof (pstatus.data.thread_info.thread_context);
7516       sect->filepos = (note->descpos
7517                        + offsetof (struct win32_pstatus,
7518                                    data.thread_info.thread_context));
7519       sect->alignment_power = 2;
7520
7521       if (pstatus.data.thread_info.is_active_thread)
7522         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7523           return FALSE;
7524       break;
7525
7526     case NOTE_INFO_MODULE:
7527       /* Make a ".module/xxxxxxxx" section.  */
7528       sprintf (buf, ".module/%08lx",
7529                (long) pstatus.data.module_info.base_address);
7530
7531       len = strlen (buf) + 1;
7532       name = bfd_alloc (abfd, len);
7533       if (name == NULL)
7534         return FALSE;
7535
7536       memcpy (name, buf, len);
7537
7538       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7539
7540       if (sect == NULL)
7541         return FALSE;
7542
7543       sect->size = note->descsz;
7544       sect->filepos = note->descpos;
7545       sect->alignment_power = 2;
7546       break;
7547
7548     default:
7549       return TRUE;
7550     }
7551
7552   return TRUE;
7553 }
7554 #endif /* HAVE_WIN32_PSTATUS_T */
7555
7556 static bfd_boolean
7557 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7558 {
7559   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7560
7561   switch (note->type)
7562     {
7563     default:
7564       return TRUE;
7565
7566     case NT_PRSTATUS:
7567       if (bed->elf_backend_grok_prstatus)
7568         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7569           return TRUE;
7570 #if defined (HAVE_PRSTATUS_T)
7571       return elfcore_grok_prstatus (abfd, note);
7572 #else
7573       return TRUE;
7574 #endif
7575
7576 #if defined (HAVE_PSTATUS_T)
7577     case NT_PSTATUS:
7578       return elfcore_grok_pstatus (abfd, note);
7579 #endif
7580
7581 #if defined (HAVE_LWPSTATUS_T)
7582     case NT_LWPSTATUS:
7583       return elfcore_grok_lwpstatus (abfd, note);
7584 #endif
7585
7586     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
7587       return elfcore_grok_prfpreg (abfd, note);
7588
7589 #if defined (HAVE_WIN32_PSTATUS_T)
7590     case NT_WIN32PSTATUS:
7591       return elfcore_grok_win32pstatus (abfd, note);
7592 #endif
7593
7594     case NT_PRXFPREG:           /* Linux SSE extension */
7595       if (note->namesz == 6
7596           && strcmp (note->namedata, "LINUX") == 0)
7597         return elfcore_grok_prxfpreg (abfd, note);
7598       else
7599         return TRUE;
7600
7601     case NT_PRPSINFO:
7602     case NT_PSINFO:
7603       if (bed->elf_backend_grok_psinfo)
7604         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7605           return TRUE;
7606 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7607       return elfcore_grok_psinfo (abfd, note);
7608 #else
7609       return TRUE;
7610 #endif
7611
7612     case NT_AUXV:
7613       {
7614         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
7615                                                              SEC_HAS_CONTENTS);
7616
7617         if (sect == NULL)
7618           return FALSE;
7619         sect->size = note->descsz;
7620         sect->filepos = note->descpos;
7621         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7622
7623         return TRUE;
7624       }
7625     }
7626 }
7627
7628 static bfd_boolean
7629 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7630 {
7631   char *cp;
7632
7633   cp = strchr (note->namedata, '@');
7634   if (cp != NULL)
7635     {
7636       *lwpidp = atoi(cp + 1);
7637       return TRUE;
7638     }
7639   return FALSE;
7640 }
7641
7642 static bfd_boolean
7643 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
7644 {
7645   /* Signal number at offset 0x08. */
7646   elf_tdata (abfd)->core_signal
7647     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7648
7649   /* Process ID at offset 0x50. */
7650   elf_tdata (abfd)->core_pid
7651     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7652
7653   /* Command name at 0x7c (max 32 bytes, including nul). */
7654   elf_tdata (abfd)->core_command
7655     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7656
7657   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7658                                           note);
7659 }
7660
7661 static bfd_boolean
7662 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
7663 {
7664   int lwp;
7665
7666   if (elfcore_netbsd_get_lwpid (note, &lwp))
7667     elf_tdata (abfd)->core_lwpid = lwp;
7668
7669   if (note->type == NT_NETBSDCORE_PROCINFO)
7670     {
7671       /* NetBSD-specific core "procinfo".  Note that we expect to
7672          find this note before any of the others, which is fine,
7673          since the kernel writes this note out first when it
7674          creates a core file.  */
7675
7676       return elfcore_grok_netbsd_procinfo (abfd, note);
7677     }
7678
7679   /* As of Jan 2002 there are no other machine-independent notes
7680      defined for NetBSD core files.  If the note type is less
7681      than the start of the machine-dependent note types, we don't
7682      understand it.  */
7683
7684   if (note->type < NT_NETBSDCORE_FIRSTMACH)
7685     return TRUE;
7686
7687
7688   switch (bfd_get_arch (abfd))
7689     {
7690       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7691          PT_GETFPREGS == mach+2.  */
7692
7693     case bfd_arch_alpha:
7694     case bfd_arch_sparc:
7695       switch (note->type)
7696         {
7697         case NT_NETBSDCORE_FIRSTMACH+0:
7698           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7699
7700         case NT_NETBSDCORE_FIRSTMACH+2:
7701           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7702
7703         default:
7704           return TRUE;
7705         }
7706
7707       /* On all other arch's, PT_GETREGS == mach+1 and
7708          PT_GETFPREGS == mach+3.  */
7709
7710     default:
7711       switch (note->type)
7712         {
7713         case NT_NETBSDCORE_FIRSTMACH+1:
7714           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7715
7716         case NT_NETBSDCORE_FIRSTMACH+3:
7717           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7718
7719         default:
7720           return TRUE;
7721         }
7722     }
7723     /* NOTREACHED */
7724 }
7725
7726 static bfd_boolean
7727 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
7728 {
7729   void *ddata = note->descdata;
7730   char buf[100];
7731   char *name;
7732   asection *sect;
7733   short sig;
7734   unsigned flags;
7735
7736   /* nto_procfs_status 'pid' field is at offset 0.  */
7737   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
7738
7739   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
7740   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
7741
7742   /* nto_procfs_status 'flags' field is at offset 8.  */
7743   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
7744
7745   /* nto_procfs_status 'what' field is at offset 14.  */
7746   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
7747     {
7748       elf_tdata (abfd)->core_signal = sig;
7749       elf_tdata (abfd)->core_lwpid = *tid;
7750     }
7751
7752   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
7753      do not come from signals so we make sure we set the current
7754      thread just in case.  */
7755   if (flags & 0x00000080)
7756     elf_tdata (abfd)->core_lwpid = *tid;
7757
7758   /* Make a ".qnx_core_status/%d" section.  */
7759   sprintf (buf, ".qnx_core_status/%ld", *tid);
7760
7761   name = bfd_alloc (abfd, strlen (buf) + 1);
7762   if (name == NULL)
7763     return FALSE;
7764   strcpy (name, buf);
7765
7766   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7767   if (sect == NULL)
7768     return FALSE;
7769
7770   sect->size            = note->descsz;
7771   sect->filepos         = note->descpos;
7772   sect->alignment_power = 2;
7773
7774   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
7775 }
7776
7777 static bfd_boolean
7778 elfcore_grok_nto_regs (bfd *abfd,
7779                        Elf_Internal_Note *note,
7780                        long tid,
7781                        char *base)
7782 {
7783   char buf[100];
7784   char *name;
7785   asection *sect;
7786
7787   /* Make a "(base)/%d" section.  */
7788   sprintf (buf, "%s/%ld", base, tid);
7789
7790   name = bfd_alloc (abfd, strlen (buf) + 1);
7791   if (name == NULL)
7792     return FALSE;
7793   strcpy (name, buf);
7794
7795   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7796   if (sect == NULL)
7797     return FALSE;
7798
7799   sect->size            = note->descsz;
7800   sect->filepos         = note->descpos;
7801   sect->alignment_power = 2;
7802
7803   /* This is the current thread.  */
7804   if (elf_tdata (abfd)->core_lwpid == tid)
7805     return elfcore_maybe_make_sect (abfd, base, sect);
7806
7807   return TRUE;
7808 }
7809
7810 #define BFD_QNT_CORE_INFO       7
7811 #define BFD_QNT_CORE_STATUS     8
7812 #define BFD_QNT_CORE_GREG       9
7813 #define BFD_QNT_CORE_FPREG      10
7814
7815 static bfd_boolean
7816 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
7817 {
7818   /* Every GREG section has a STATUS section before it.  Store the
7819      tid from the previous call to pass down to the next gregs
7820      function.  */
7821   static long tid = 1;
7822
7823   switch (note->type)
7824     {
7825     case BFD_QNT_CORE_INFO:
7826       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7827     case BFD_QNT_CORE_STATUS:
7828       return elfcore_grok_nto_status (abfd, note, &tid);
7829     case BFD_QNT_CORE_GREG:
7830       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
7831     case BFD_QNT_CORE_FPREG:
7832       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
7833     default:
7834       return TRUE;
7835     }
7836 }
7837
7838 /* Function: elfcore_write_note
7839
7840    Inputs:
7841      buffer to hold note, and current size of buffer
7842      name of note
7843      type of note
7844      data for note
7845      size of data for note
7846
7847    Writes note to end of buffer.  ELF64 notes are written exactly as
7848    for ELF32, despite the current (as of 2006) ELF gabi specifying
7849    that they ought to have 8-byte namesz and descsz field, and have
7850    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
7851
7852    Return:
7853    Pointer to realloc'd buffer, *BUFSIZ updated.  */
7854
7855 char *
7856 elfcore_write_note (bfd *abfd,
7857                     char *buf,
7858                     int *bufsiz,
7859                     const char *name,
7860                     int type,
7861                     const void *input,
7862                     int size)
7863 {
7864   Elf_External_Note *xnp;
7865   size_t namesz;
7866   size_t newspace;
7867   char *dest;
7868
7869   namesz = 0;
7870   if (name != NULL)
7871     namesz = strlen (name) + 1;
7872
7873   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
7874
7875   buf = realloc (buf, *bufsiz + newspace);
7876   dest = buf + *bufsiz;
7877   *bufsiz += newspace;
7878   xnp = (Elf_External_Note *) dest;
7879   H_PUT_32 (abfd, namesz, xnp->namesz);
7880   H_PUT_32 (abfd, size, xnp->descsz);
7881   H_PUT_32 (abfd, type, xnp->type);
7882   dest = xnp->name;
7883   if (name != NULL)
7884     {
7885       memcpy (dest, name, namesz);
7886       dest += namesz;
7887       while (namesz & 3)
7888         {
7889           *dest++ = '\0';
7890           ++namesz;
7891         }
7892     }
7893   memcpy (dest, input, size);
7894   dest += size;
7895   while (size & 3)
7896     {
7897       *dest++ = '\0';
7898       ++size;
7899     }
7900   return buf;
7901 }
7902
7903 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7904 char *
7905 elfcore_write_prpsinfo (bfd  *abfd,
7906                         char *buf,
7907                         int  *bufsiz,
7908                         const char *fname,
7909                         const char *psargs)
7910 {
7911   const char *note_name = "CORE";
7912   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7913
7914   if (bed->elf_backend_write_core_note != NULL)
7915     {
7916       char *ret;
7917       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
7918                                                  NT_PRPSINFO, fname, psargs);
7919       if (ret != NULL)
7920         return ret;
7921     }
7922
7923 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7924   if (bed->s->elfclass == ELFCLASS32)
7925     {
7926 #if defined (HAVE_PSINFO32_T)
7927       psinfo32_t data;
7928       int note_type = NT_PSINFO;
7929 #else
7930       prpsinfo32_t data;
7931       int note_type = NT_PRPSINFO;
7932 #endif
7933
7934       memset (&data, 0, sizeof (data));
7935       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7936       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7937       return elfcore_write_note (abfd, buf, bufsiz,
7938                                  note_name, note_type, &data, sizeof (data));
7939     }
7940   else
7941 #endif
7942     {
7943 #if defined (HAVE_PSINFO_T)
7944       psinfo_t data;
7945       int note_type = NT_PSINFO;
7946 #else
7947       prpsinfo_t data;
7948       int note_type = NT_PRPSINFO;
7949 #endif
7950
7951       memset (&data, 0, sizeof (data));
7952       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7953       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7954       return elfcore_write_note (abfd, buf, bufsiz,
7955                                  note_name, note_type, &data, sizeof (data));
7956     }
7957 }
7958 #endif  /* PSINFO_T or PRPSINFO_T */
7959
7960 #if defined (HAVE_PRSTATUS_T)
7961 char *
7962 elfcore_write_prstatus (bfd *abfd,
7963                         char *buf,
7964                         int *bufsiz,
7965                         long pid,
7966                         int cursig,
7967                         const void *gregs)
7968 {
7969   const char *note_name = "CORE";
7970   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7971
7972   if (bed->elf_backend_write_core_note != NULL)
7973     {
7974       char *ret;
7975       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
7976                                                  NT_PRSTATUS,
7977                                                  pid, cursig, gregs);
7978       if (ret != NULL)
7979         return ret;
7980     }
7981
7982 #if defined (HAVE_PRSTATUS32_T)
7983   if (bed->s->elfclass == ELFCLASS32)
7984     {
7985       prstatus32_t prstat;
7986
7987       memset (&prstat, 0, sizeof (prstat));
7988       prstat.pr_pid = pid;
7989       prstat.pr_cursig = cursig;
7990       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7991       return elfcore_write_note (abfd, buf, bufsiz, note_name,
7992                                  NT_PRSTATUS, &prstat, sizeof (prstat));
7993     }
7994   else
7995 #endif
7996     {
7997       prstatus_t prstat;
7998
7999       memset (&prstat, 0, sizeof (prstat));
8000       prstat.pr_pid = pid;
8001       prstat.pr_cursig = cursig;
8002       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8003       return elfcore_write_note (abfd, buf, bufsiz, note_name,
8004                                  NT_PRSTATUS, &prstat, sizeof (prstat));
8005     }
8006 }
8007 #endif /* HAVE_PRSTATUS_T */
8008
8009 #if defined (HAVE_LWPSTATUS_T)
8010 char *
8011 elfcore_write_lwpstatus (bfd *abfd,
8012                          char *buf,
8013                          int *bufsiz,
8014                          long pid,
8015                          int cursig,
8016                          const void *gregs)
8017 {
8018   lwpstatus_t lwpstat;
8019   const char *note_name = "CORE";
8020
8021   memset (&lwpstat, 0, sizeof (lwpstat));
8022   lwpstat.pr_lwpid  = pid >> 16;
8023   lwpstat.pr_cursig = cursig;
8024 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8025   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8026 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8027 #if !defined(gregs)
8028   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8029           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8030 #else
8031   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8032           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8033 #endif
8034 #endif
8035   return elfcore_write_note (abfd, buf, bufsiz, note_name,
8036                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8037 }
8038 #endif /* HAVE_LWPSTATUS_T */
8039
8040 #if defined (HAVE_PSTATUS_T)
8041 char *
8042 elfcore_write_pstatus (bfd *abfd,
8043                        char *buf,
8044                        int *bufsiz,
8045                        long pid,
8046                        int cursig ATTRIBUTE_UNUSED,
8047                        const void *gregs ATTRIBUTE_UNUSED)
8048 {
8049   const char *note_name = "CORE";
8050 #if defined (HAVE_PSTATUS32_T)
8051   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8052
8053   if (bed->s->elfclass == ELFCLASS32)
8054     {
8055       pstatus32_t pstat;
8056
8057       memset (&pstat, 0, sizeof (pstat));
8058       pstat.pr_pid = pid & 0xffff;
8059       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8060                                 NT_PSTATUS, &pstat, sizeof (pstat));
8061       return buf;
8062     }
8063   else
8064 #endif
8065     {
8066       pstatus_t pstat;
8067
8068       memset (&pstat, 0, sizeof (pstat));
8069       pstat.pr_pid = pid & 0xffff;
8070       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8071                                 NT_PSTATUS, &pstat, sizeof (pstat));
8072       return buf;
8073     }
8074 }
8075 #endif /* HAVE_PSTATUS_T */
8076
8077 char *
8078 elfcore_write_prfpreg (bfd *abfd,
8079                        char *buf,
8080                        int *bufsiz,
8081                        const void *fpregs,
8082                        int size)
8083 {
8084   const char *note_name = "CORE";
8085   return elfcore_write_note (abfd, buf, bufsiz,
8086                              note_name, NT_FPREGSET, fpregs, size);
8087 }
8088
8089 char *
8090 elfcore_write_prxfpreg (bfd *abfd,
8091                         char *buf,
8092                         int *bufsiz,
8093                         const void *xfpregs,
8094                         int size)
8095 {
8096   char *note_name = "LINUX";
8097   return elfcore_write_note (abfd, buf, bufsiz,
8098                              note_name, NT_PRXFPREG, xfpregs, size);
8099 }
8100
8101 static bfd_boolean
8102 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
8103 {
8104   char *buf;
8105   char *p;
8106
8107   if (size <= 0)
8108     return TRUE;
8109
8110   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
8111     return FALSE;
8112
8113   buf = bfd_malloc (size);
8114   if (buf == NULL)
8115     return FALSE;
8116
8117   if (bfd_bread (buf, size, abfd) != size)
8118     {
8119     error:
8120       free (buf);
8121       return FALSE;
8122     }
8123
8124   p = buf;
8125   while (p < buf + size)
8126     {
8127       /* FIXME: bad alignment assumption.  */
8128       Elf_External_Note *xnp = (Elf_External_Note *) p;
8129       Elf_Internal_Note in;
8130
8131       in.type = H_GET_32 (abfd, xnp->type);
8132
8133       in.namesz = H_GET_32 (abfd, xnp->namesz);
8134       in.namedata = xnp->name;
8135
8136       in.descsz = H_GET_32 (abfd, xnp->descsz);
8137       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8138       in.descpos = offset + (in.descdata - buf);
8139
8140       if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
8141         {
8142           if (! elfcore_grok_netbsd_note (abfd, &in))
8143             goto error;
8144         }
8145       else if (CONST_STRNEQ (in.namedata, "QNX"))
8146         {
8147           if (! elfcore_grok_nto_note (abfd, &in))
8148             goto error;
8149         }
8150       else
8151         {
8152           if (! elfcore_grok_note (abfd, &in))
8153             goto error;
8154         }
8155
8156       p = in.descdata + BFD_ALIGN (in.descsz, 4);
8157     }
8158
8159   free (buf);
8160   return TRUE;
8161 }
8162 \f
8163 /* Providing external access to the ELF program header table.  */
8164
8165 /* Return an upper bound on the number of bytes required to store a
8166    copy of ABFD's program header table entries.  Return -1 if an error
8167    occurs; bfd_get_error will return an appropriate code.  */
8168
8169 long
8170 bfd_get_elf_phdr_upper_bound (bfd *abfd)
8171 {
8172   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8173     {
8174       bfd_set_error (bfd_error_wrong_format);
8175       return -1;
8176     }
8177
8178   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
8179 }
8180
8181 /* Copy ABFD's program header table entries to *PHDRS.  The entries
8182    will be stored as an array of Elf_Internal_Phdr structures, as
8183    defined in include/elf/internal.h.  To find out how large the
8184    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8185
8186    Return the number of program header table entries read, or -1 if an
8187    error occurs; bfd_get_error will return an appropriate code.  */
8188
8189 int
8190 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
8191 {
8192   int num_phdrs;
8193
8194   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8195     {
8196       bfd_set_error (bfd_error_wrong_format);
8197       return -1;
8198     }
8199
8200   num_phdrs = elf_elfheader (abfd)->e_phnum;
8201   memcpy (phdrs, elf_tdata (abfd)->phdr,
8202           num_phdrs * sizeof (Elf_Internal_Phdr));
8203
8204   return num_phdrs;
8205 }
8206
8207 void
8208 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
8209 {
8210 #ifdef BFD64
8211   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
8212
8213   i_ehdrp = elf_elfheader (abfd);
8214   if (i_ehdrp == NULL)
8215     sprintf_vma (buf, value);
8216   else
8217     {
8218       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
8219         {
8220 #if BFD_HOST_64BIT_LONG
8221           sprintf (buf, "%016lx", value);
8222 #else
8223           sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
8224                    _bfd_int64_low (value));
8225 #endif
8226         }
8227       else
8228         sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
8229     }
8230 #else
8231   sprintf_vma (buf, value);
8232 #endif
8233 }
8234
8235 void
8236 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
8237 {
8238 #ifdef BFD64
8239   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
8240
8241   i_ehdrp = elf_elfheader (abfd);
8242   if (i_ehdrp == NULL)
8243     fprintf_vma ((FILE *) stream, value);
8244   else
8245     {
8246       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
8247         {
8248 #if BFD_HOST_64BIT_LONG
8249           fprintf ((FILE *) stream, "%016lx", value);
8250 #else
8251           fprintf ((FILE *) stream, "%08lx%08lx",
8252                    _bfd_int64_high (value), _bfd_int64_low (value));
8253 #endif
8254         }
8255       else
8256         fprintf ((FILE *) stream, "%08lx",
8257                  (unsigned long) (value & 0xffffffff));
8258     }
8259 #else
8260   fprintf_vma ((FILE *) stream, value);
8261 #endif
8262 }
8263
8264 enum elf_reloc_type_class
8265 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8266 {
8267   return reloc_class_normal;
8268 }
8269
8270 /* For RELA architectures, return the relocation value for a
8271    relocation against a local symbol.  */
8272
8273 bfd_vma
8274 _bfd_elf_rela_local_sym (bfd *abfd,
8275                          Elf_Internal_Sym *sym,
8276                          asection **psec,
8277                          Elf_Internal_Rela *rel)
8278 {
8279   asection *sec = *psec;
8280   bfd_vma relocation;
8281
8282   relocation = (sec->output_section->vma
8283                 + sec->output_offset
8284                 + sym->st_value);
8285   if ((sec->flags & SEC_MERGE)
8286       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8287       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8288     {
8289       rel->r_addend =
8290         _bfd_merged_section_offset (abfd, psec,
8291                                     elf_section_data (sec)->sec_info,
8292                                     sym->st_value + rel->r_addend);
8293       if (sec != *psec)
8294         {
8295           /* If we have changed the section, and our original section is
8296              marked with SEC_EXCLUDE, it means that the original
8297              SEC_MERGE section has been completely subsumed in some
8298              other SEC_MERGE section.  In this case, we need to leave
8299              some info around for --emit-relocs.  */
8300           if ((sec->flags & SEC_EXCLUDE) != 0)
8301             sec->kept_section = *psec;
8302           sec = *psec;
8303         }
8304       rel->r_addend -= relocation;
8305       rel->r_addend += sec->output_section->vma + sec->output_offset;
8306     }
8307   return relocation;
8308 }
8309
8310 bfd_vma
8311 _bfd_elf_rel_local_sym (bfd *abfd,
8312                         Elf_Internal_Sym *sym,
8313                         asection **psec,
8314                         bfd_vma addend)
8315 {
8316   asection *sec = *psec;
8317
8318   if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8319     return sym->st_value + addend;
8320
8321   return _bfd_merged_section_offset (abfd, psec,
8322                                      elf_section_data (sec)->sec_info,
8323                                      sym->st_value + addend);
8324 }
8325
8326 bfd_vma
8327 _bfd_elf_section_offset (bfd *abfd,
8328                          struct bfd_link_info *info,
8329                          asection *sec,
8330                          bfd_vma offset)
8331 {
8332   switch (sec->sec_info_type)
8333     {
8334     case ELF_INFO_TYPE_STABS:
8335       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8336                                        offset);
8337     case ELF_INFO_TYPE_EH_FRAME:
8338       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8339     default:
8340       return offset;
8341     }
8342 }
8343 \f
8344 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
8345    reconstruct an ELF file by reading the segments out of remote memory
8346    based on the ELF file header at EHDR_VMA and the ELF program headers it
8347    points to.  If not null, *LOADBASEP is filled in with the difference
8348    between the VMAs from which the segments were read, and the VMAs the
8349    file headers (and hence BFD's idea of each section's VMA) put them at.
8350
8351    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8352    remote memory at target address VMA into the local buffer at MYADDR; it
8353    should return zero on success or an `errno' code on failure.  TEMPL must
8354    be a BFD for an ELF target with the word size and byte order found in
8355    the remote memory.  */
8356
8357 bfd *
8358 bfd_elf_bfd_from_remote_memory
8359   (bfd *templ,
8360    bfd_vma ehdr_vma,
8361    bfd_vma *loadbasep,
8362    int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8363 {
8364   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8365     (templ, ehdr_vma, loadbasep, target_read_memory);
8366 }
8367 \f
8368 long
8369 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8370                                long symcount ATTRIBUTE_UNUSED,
8371                                asymbol **syms ATTRIBUTE_UNUSED,
8372                                long dynsymcount,
8373                                asymbol **dynsyms,
8374                                asymbol **ret)
8375 {
8376   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8377   asection *relplt;
8378   asymbol *s;
8379   const char *relplt_name;
8380   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8381   arelent *p;
8382   long count, i, n;
8383   size_t size;
8384   Elf_Internal_Shdr *hdr;
8385   char *names;
8386   asection *plt;
8387
8388   *ret = NULL;
8389
8390   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8391     return 0;
8392
8393   if (dynsymcount <= 0)
8394     return 0;
8395
8396   if (!bed->plt_sym_val)
8397     return 0;
8398
8399   relplt_name = bed->relplt_name;
8400   if (relplt_name == NULL)
8401     relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8402   relplt = bfd_get_section_by_name (abfd, relplt_name);
8403   if (relplt == NULL)
8404     return 0;
8405
8406   hdr = &elf_section_data (relplt)->this_hdr;
8407   if (hdr->sh_link != elf_dynsymtab (abfd)
8408       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8409     return 0;
8410
8411   plt = bfd_get_section_by_name (abfd, ".plt");
8412   if (plt == NULL)
8413     return 0;
8414
8415   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8416   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8417     return -1;
8418
8419   count = relplt->size / hdr->sh_entsize;
8420   size = count * sizeof (asymbol);
8421   p = relplt->relocation;
8422   for (i = 0; i < count; i++, p++)
8423     size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8424
8425   s = *ret = bfd_malloc (size);
8426   if (s == NULL)
8427     return -1;
8428
8429   names = (char *) (s + count);
8430   p = relplt->relocation;
8431   n = 0;
8432   for (i = 0; i < count; i++, s++, p++)
8433     {
8434       size_t len;
8435       bfd_vma addr;
8436
8437       addr = bed->plt_sym_val (i, plt, p);
8438       if (addr == (bfd_vma) -1)
8439         continue;
8440
8441       *s = **p->sym_ptr_ptr;
8442       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
8443          we are defining a symbol, ensure one of them is set.  */
8444       if ((s->flags & BSF_LOCAL) == 0)
8445         s->flags |= BSF_GLOBAL;
8446       s->section = plt;
8447       s->value = addr - plt->vma;
8448       s->name = names;
8449       len = strlen ((*p->sym_ptr_ptr)->name);
8450       memcpy (names, (*p->sym_ptr_ptr)->name, len);
8451       names += len;
8452       memcpy (names, "@plt", sizeof ("@plt"));
8453       names += sizeof ("@plt");
8454       ++n;
8455     }
8456
8457   return n;
8458 }
8459
8460 /* It is only used by x86-64 so far.  */
8461 asection _bfd_elf_large_com_section
8462   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
8463                       SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
8464
8465 void
8466 _bfd_elf_set_osabi (bfd * abfd,
8467                     struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
8468 {
8469   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
8470
8471   i_ehdrp = elf_elfheader (abfd);
8472
8473   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
8474 }
8475
8476
8477 /* Return TRUE for ELF symbol types that represent functions.
8478    This is the default version of this function, which is sufficient for
8479    most targets.  It returns true if TYPE is STT_FUNC.  */
8480
8481 bfd_boolean
8482 _bfd_elf_is_function_type (unsigned int type)
8483 {
8484   return (type == STT_FUNC);
8485 }