bfd/elf.c

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