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