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