bfd/elf.c

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