bfd/elf.c

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