bfd/elf.c

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