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