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