bfd/elf.c

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