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 char *
 214 elf_read (bfd *abfd, file_ptr offset, bfd_size_type size)
 215 {
 216   char *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   char *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 0;
 263
 264   shstrtab = (char *) 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 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       if (bed->elf_backend_section_from_shdr)
2043         (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
2044       break;
2045     }
2046
2047   return TRUE;
2048 }
2049
2050 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2051    Return SEC for sections that have no elf section, and NULL on error.  */
2052
2053 asection *
2054 bfd_section_from_r_symndx (bfd *abfd,
2055                            struct sym_sec_cache *cache,
2056                            asection *sec,
2057                            unsigned long r_symndx)
2058 {
2059   Elf_Internal_Shdr *symtab_hdr;
2060   unsigned char esym[sizeof (Elf64_External_Sym)];
2061   Elf_External_Sym_Shndx eshndx;
2062   Elf_Internal_Sym isym;
2063   unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2064
2065   if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
2066     return cache->sec[ent];
2067
2068   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2069   if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2070                             &isym, esym, &eshndx) == NULL)
2071     return NULL;
2072
2073   if (cache->abfd != abfd)
2074     {
2075       memset (cache->indx, -1, sizeof (cache->indx));
2076       cache->abfd = abfd;
2077     }
2078   cache->indx[ent] = r_symndx;
2079   cache->sec[ent] = sec;
2080   if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
2081       || isym.st_shndx > SHN_HIRESERVE)
2082     {
2083       asection *s;
2084       s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2085       if (s != NULL)
2086         cache->sec[ent] = s;
2087     }
2088   return cache->sec[ent];
2089 }
2090
2091 /* Given an ELF section number, retrieve the corresponding BFD
2092    section.  */
2093
2094 asection *
2095 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
2096 {
2097   if (index >= elf_numsections (abfd))
2098     return NULL;
2099   return elf_elfsections (abfd)[index]->bfd_section;
2100 }
2101
2102 static struct bfd_elf_special_section const special_sections[] =
2103 {
2104   { ".bss",            4, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2105   { ".gnu.linkonce.b",15, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2106   { ".comment",        8,  0, SHT_PROGBITS, 0 },
2107   { ".data",           5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2108   { ".data1",          6,  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2109   { ".debug",          6,  0, SHT_PROGBITS, 0 },
2110   { ".fini",           5,  0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2111   { ".init",           5,  0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2112   { ".line",           5,  0, SHT_PROGBITS, 0 },
2113   { ".rodata",         7, -2, SHT_PROGBITS, SHF_ALLOC },
2114   { ".rodata1",        8,  0, SHT_PROGBITS, SHF_ALLOC },
2115   { ".tbss",           5, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_TLS },
2116   { ".tdata",          6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2117   { ".text",           5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2118   { ".init_array",    11,  0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2119   { ".fini_array",    11,  0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2120   { ".preinit_array", 14,  0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2121   { ".debug_line",    11,  0, SHT_PROGBITS, 0 },
2122   { ".debug_info",    11,  0, SHT_PROGBITS, 0 },
2123   { ".debug_abbrev",  13,  0, SHT_PROGBITS, 0 },
2124   { ".debug_aranges", 14,  0, SHT_PROGBITS, 0 },
2125   { ".dynamic",        8,  0, SHT_DYNAMIC,  SHF_ALLOC },
2126   { ".dynstr",         7,  0, SHT_STRTAB,   SHF_ALLOC },
2127   { ".dynsym",         7,  0, SHT_DYNSYM,   SHF_ALLOC },
2128   { ".got",            4,  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2129   { ".hash",           5,  0, SHT_HASH,     SHF_ALLOC },
2130   { ".interp",         7,  0, SHT_PROGBITS, 0 },
2131   { ".plt",            4,  0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2132   { ".shstrtab",       9,  0, SHT_STRTAB,   0 },
2133   { ".strtab",         7,  0, SHT_STRTAB,   0 },
2134   { ".symtab",         7,  0, SHT_SYMTAB,   0 },
2135   { ".gnu.version",   12,  0, SHT_GNU_versym, 0 },
2136   { ".gnu.version_d", 14,  0, SHT_GNU_verdef, 0 },
2137   { ".gnu.version_r", 14,  0, SHT_GNU_verneed, 0 },
2138   { ".note.GNU-stack",15,  0, SHT_PROGBITS, 0 },
2139   { ".note",           5, -1, SHT_NOTE,     0 },
2140   { ".rela",           5, -1, SHT_RELA,     0 },
2141   { ".rel",            4, -1, SHT_REL,      0 },
2142   { ".stabstr",        5,  3, SHT_STRTAB,   0 },
2143   { ".gnu.liblist",   12,  0, SHT_GNU_LIBLIST, SHF_ALLOC },
2144   { ".gnu.conflict",  13,  0, SHT_RELA,     SHF_ALLOC },
2145   { NULL,              0,  0, 0,            0 }
2146 };
2147
2148 static const struct bfd_elf_special_section *
2149 get_special_section (const char *name,
2150                      const struct bfd_elf_special_section *special_sections,
2151                      unsigned int rela)
2152 {
2153   int i;
2154   int len = strlen (name);
2155
2156   for (i = 0; special_sections[i].prefix != NULL; i++)
2157     {
2158       int suffix_len;
2159       int prefix_len = special_sections[i].prefix_length;
2160
2161       if (len < prefix_len)
2162         continue;
2163       if (memcmp (name, special_sections[i].prefix, prefix_len) != 0)
2164         continue;
2165
2166       suffix_len = special_sections[i].suffix_length;
2167       if (suffix_len <= 0)
2168         {
2169           if (name[prefix_len] != 0)
2170             {
2171               if (suffix_len == 0)
2172                 continue;
2173               if (name[prefix_len] != '.'
2174                   && (suffix_len == -2
2175                       || (rela && special_sections[i].type == SHT_REL)))
2176                 continue;
2177             }
2178         }
2179       else
2180         {
2181           if (len < prefix_len + suffix_len)
2182             continue;
2183           if (memcmp (name + len - suffix_len,
2184                       special_sections[i].prefix + prefix_len,
2185                       suffix_len) != 0)
2186             continue;
2187         }
2188       return &special_sections[i];
2189     }
2190
2191   return NULL;
2192 }
2193
2194 const struct bfd_elf_special_section *
2195 _bfd_elf_get_sec_type_attr (bfd *abfd, const char *name)
2196 {
2197   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2198   const struct bfd_elf_special_section *ssect = NULL;
2199
2200   /* See if this is one of the special sections.  */
2201   if (name)
2202     {
2203       unsigned int rela = bed->default_use_rela_p;
2204
2205       if (bed->special_sections)
2206         ssect = get_special_section (name, bed->special_sections, rela);
2207
2208       if (! ssect)
2209         ssect = get_special_section (name, special_sections, rela);
2210     }
2211
2212   return ssect;
2213 }
2214
2215 bfd_boolean
2216 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2217 {
2218   struct bfd_elf_section_data *sdata;
2219   const struct bfd_elf_special_section *ssect;
2220
2221   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2222   if (sdata == NULL)
2223     {
2224       sdata = bfd_zalloc (abfd, sizeof (*sdata));
2225       if (sdata == NULL)
2226         return FALSE;
2227       sec->used_by_bfd = sdata;
2228     }
2229
2230   elf_section_type (sec) = SHT_NULL;
2231   ssect = _bfd_elf_get_sec_type_attr (abfd, sec->name);
2232   if (ssect != NULL)
2233     {
2234       elf_section_type (sec) = ssect->type;
2235       elf_section_flags (sec) = ssect->attr;
2236     }
2237
2238   /* Indicate whether or not this section should use RELA relocations.  */
2239   sec->use_rela_p = get_elf_backend_data (abfd)->default_use_rela_p;
2240
2241   return TRUE;
2242 }
2243
2244 /* Create a new bfd section from an ELF program header.
2245
2246    Since program segments have no names, we generate a synthetic name
2247    of the form segment<NUM>, where NUM is generally the index in the
2248    program header table.  For segments that are split (see below) we
2249    generate the names segment<NUM>a and segment<NUM>b.
2250
2251    Note that some program segments may have a file size that is different than
2252    (less than) the memory size.  All this means is that at execution the
2253    system must allocate the amount of memory specified by the memory size,
2254    but only initialize it with the first "file size" bytes read from the
2255    file.  This would occur for example, with program segments consisting
2256    of combined data+bss.
2257
2258    To handle the above situation, this routine generates TWO bfd sections
2259    for the single program segment.  The first has the length specified by
2260    the file size of the segment, and the second has the length specified
2261    by the difference between the two sizes.  In effect, the segment is split
2262    into it's initialized and uninitialized parts.
2263
2264  */
2265
2266 bfd_boolean
2267 _bfd_elf_make_section_from_phdr (bfd *abfd,
2268                                  Elf_Internal_Phdr *hdr,
2269                                  int index,
2270                                  const char *typename)
2271 {
2272   asection *newsect;
2273   char *name;
2274   char namebuf[64];
2275   size_t len;
2276   int split;
2277
2278   split = ((hdr->p_memsz > 0)
2279             && (hdr->p_filesz > 0)
2280             && (hdr->p_memsz > hdr->p_filesz));
2281   sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2282   len = strlen (namebuf) + 1;
2283   name = bfd_alloc (abfd, len);
2284   if (!name)
2285     return FALSE;
2286   memcpy (name, namebuf, len);
2287   newsect = bfd_make_section (abfd, name);
2288   if (newsect == NULL)
2289     return FALSE;
2290   newsect->vma = hdr->p_vaddr;
2291   newsect->lma = hdr->p_paddr;
2292   newsect->size = hdr->p_filesz;
2293   newsect->filepos = hdr->p_offset;
2294   newsect->flags |= SEC_HAS_CONTENTS;
2295   newsect->alignment_power = bfd_log2 (hdr->p_align);
2296   if (hdr->p_type == PT_LOAD)
2297     {
2298       newsect->flags |= SEC_ALLOC;
2299       newsect->flags |= SEC_LOAD;
2300       if (hdr->p_flags & PF_X)
2301         {
2302           /* FIXME: all we known is that it has execute PERMISSION,
2303              may be data.  */
2304           newsect->flags |= SEC_CODE;
2305         }
2306     }
2307   if (!(hdr->p_flags & PF_W))
2308     {
2309       newsect->flags |= SEC_READONLY;
2310     }
2311
2312   if (split)
2313     {
2314       sprintf (namebuf, "%s%db", typename, index);
2315       len = strlen (namebuf) + 1;
2316       name = bfd_alloc (abfd, len);
2317       if (!name)
2318         return FALSE;
2319       memcpy (name, namebuf, len);
2320       newsect = bfd_make_section (abfd, name);
2321       if (newsect == NULL)
2322         return FALSE;
2323       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2324       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2325       newsect->size = hdr->p_memsz - hdr->p_filesz;
2326       if (hdr->p_type == PT_LOAD)
2327         {
2328           newsect->flags |= SEC_ALLOC;
2329           if (hdr->p_flags & PF_X)
2330             newsect->flags |= SEC_CODE;
2331         }
2332       if (!(hdr->p_flags & PF_W))
2333         newsect->flags |= SEC_READONLY;
2334     }
2335
2336   return TRUE;
2337 }
2338
2339 bfd_boolean
2340 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2341 {
2342   const struct elf_backend_data *bed;
2343
2344   switch (hdr->p_type)
2345     {
2346     case PT_NULL:
2347       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2348
2349     case PT_LOAD:
2350       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2351
2352     case PT_DYNAMIC:
2353       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2354
2355     case PT_INTERP:
2356       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2357
2358     case PT_NOTE:
2359       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2360         return FALSE;
2361       if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2362         return FALSE;
2363       return TRUE;
2364
2365     case PT_SHLIB:
2366       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2367
2368     case PT_PHDR:
2369       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2370
2371     case PT_GNU_EH_FRAME:
2372       return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2373                                               "eh_frame_hdr");
2374
2375     case PT_GNU_STACK:
2376       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2377
2378     case PT_GNU_RELRO:
2379       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2380
2381     default:
2382       /* Check for any processor-specific program segment types.
2383          If no handler for them, default to making "segment" sections.  */
2384       bed = get_elf_backend_data (abfd);
2385       if (bed->elf_backend_section_from_phdr)
2386         return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
2387       else
2388         return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
2389     }
2390 }
2391
2392 /* Initialize REL_HDR, the section-header for new section, containing
2393    relocations against ASECT.  If USE_RELA_P is TRUE, we use RELA
2394    relocations; otherwise, we use REL relocations.  */
2395
2396 bfd_boolean
2397 _bfd_elf_init_reloc_shdr (bfd *abfd,
2398                           Elf_Internal_Shdr *rel_hdr,
2399                           asection *asect,
2400                           bfd_boolean use_rela_p)
2401 {
2402   char *name;
2403   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2404   bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2405
2406   name = bfd_alloc (abfd, amt);
2407   if (name == NULL)
2408     return FALSE;
2409   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2410   rel_hdr->sh_name =
2411     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2412                                         FALSE);
2413   if (rel_hdr->sh_name == (unsigned int) -1)
2414     return FALSE;
2415   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2416   rel_hdr->sh_entsize = (use_rela_p
2417                          ? bed->s->sizeof_rela
2418                          : bed->s->sizeof_rel);
2419   rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2420   rel_hdr->sh_flags = 0;
2421   rel_hdr->sh_addr = 0;
2422   rel_hdr->sh_size = 0;
2423   rel_hdr->sh_offset = 0;
2424
2425   return TRUE;
2426 }
2427
2428 /* Set up an ELF internal section header for a section.  */
2429
2430 static void
2431 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2432 {
2433   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2434   bfd_boolean *failedptr = failedptrarg;
2435   Elf_Internal_Shdr *this_hdr;
2436
2437   if (*failedptr)
2438     {
2439       /* We already failed; just get out of the bfd_map_over_sections
2440          loop.  */
2441       return;
2442     }
2443
2444   this_hdr = &elf_section_data (asect)->this_hdr;
2445
2446   this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2447                                                           asect->name, FALSE);
2448   if (this_hdr->sh_name == (unsigned int) -1)
2449     {
2450       *failedptr = TRUE;
2451       return;
2452     }
2453
2454   this_hdr->sh_flags = 0;
2455
2456   if ((asect->flags & SEC_ALLOC) != 0
2457       || asect->user_set_vma)
2458     this_hdr->sh_addr = asect->vma;
2459   else
2460     this_hdr->sh_addr = 0;
2461
2462   this_hdr->sh_offset = 0;
2463   this_hdr->sh_size = asect->size;
2464   this_hdr->sh_link = 0;
2465   this_hdr->sh_addralign = 1 << asect->alignment_power;
2466   /* The sh_entsize and sh_info fields may have been set already by
2467      copy_private_section_data.  */
2468
2469   this_hdr->bfd_section = asect;
2470   this_hdr->contents = NULL;
2471
2472   /* If the section type is unspecified, we set it based on
2473      asect->flags.  */
2474   if (this_hdr->sh_type == SHT_NULL)
2475     {
2476       if ((asect->flags & SEC_GROUP) != 0)
2477         {
2478           /* We also need to mark SHF_GROUP here for relocatable
2479              link.  */
2480           struct bfd_link_order *l;
2481           asection *elt;
2482
2483           for (l = asect->link_order_head; l != NULL; l = l->next)
2484             if (l->type == bfd_indirect_link_order
2485                 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2486               do
2487                 {
2488                   /* The name is not important. Anything will do.  */
2489                   elf_group_name (elt->output_section) = "G";
2490                   elf_section_flags (elt->output_section) |= SHF_GROUP;
2491
2492                   elt = elf_next_in_group (elt);
2493                   /* During a relocatable link, the lists are
2494                      circular.  */
2495                 }
2496               while (elt != elf_next_in_group (l->u.indirect.section));
2497
2498           this_hdr->sh_type = SHT_GROUP;
2499         }
2500       else if ((asect->flags & SEC_ALLOC) != 0
2501           && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2502               || (asect->flags & SEC_NEVER_LOAD) != 0))
2503         this_hdr->sh_type = SHT_NOBITS;
2504       else
2505         this_hdr->sh_type = SHT_PROGBITS;
2506     }
2507
2508   switch (this_hdr->sh_type)
2509     {
2510     default:
2511       break;
2512
2513     case SHT_STRTAB:
2514     case SHT_INIT_ARRAY:
2515     case SHT_FINI_ARRAY:
2516     case SHT_PREINIT_ARRAY:
2517     case SHT_NOTE:
2518     case SHT_NOBITS:
2519     case SHT_PROGBITS:
2520       break;
2521
2522     case SHT_HASH:
2523       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2524       break;
2525
2526     case SHT_DYNSYM:
2527       this_hdr->sh_entsize = bed->s->sizeof_sym;
2528       break;
2529
2530     case SHT_DYNAMIC:
2531       this_hdr->sh_entsize = bed->s->sizeof_dyn;
2532       break;
2533
2534     case SHT_RELA:
2535       if (get_elf_backend_data (abfd)->may_use_rela_p)
2536         this_hdr->sh_entsize = bed->s->sizeof_rela;
2537       break;
2538
2539      case SHT_REL:
2540       if (get_elf_backend_data (abfd)->may_use_rel_p)
2541         this_hdr->sh_entsize = bed->s->sizeof_rel;
2542       break;
2543
2544      case SHT_GNU_versym:
2545       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2546       break;
2547
2548      case SHT_GNU_verdef:
2549       this_hdr->sh_entsize = 0;
2550       /* objcopy or strip will copy over sh_info, but may not set
2551          cverdefs.  The linker will set cverdefs, but sh_info will be
2552          zero.  */
2553       if (this_hdr->sh_info == 0)
2554         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2555       else
2556         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2557                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2558       break;
2559
2560     case SHT_GNU_verneed:
2561       this_hdr->sh_entsize = 0;
2562       /* objcopy or strip will copy over sh_info, but may not set
2563          cverrefs.  The linker will set cverrefs, but sh_info will be
2564          zero.  */
2565       if (this_hdr->sh_info == 0)
2566         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2567       else
2568         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2569                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2570       break;
2571
2572     case SHT_GROUP:
2573       this_hdr->sh_entsize = 4;
2574       break;
2575     }
2576
2577   if ((asect->flags & SEC_ALLOC) != 0)
2578     this_hdr->sh_flags |= SHF_ALLOC;
2579   if ((asect->flags & SEC_READONLY) == 0)
2580     this_hdr->sh_flags |= SHF_WRITE;
2581   if ((asect->flags & SEC_CODE) != 0)
2582     this_hdr->sh_flags |= SHF_EXECINSTR;
2583   if ((asect->flags & SEC_MERGE) != 0)
2584     {
2585       this_hdr->sh_flags |= SHF_MERGE;
2586       this_hdr->sh_entsize = asect->entsize;
2587       if ((asect->flags & SEC_STRINGS) != 0)
2588         this_hdr->sh_flags |= SHF_STRINGS;
2589     }
2590   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2591     this_hdr->sh_flags |= SHF_GROUP;
2592   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2593     {
2594       this_hdr->sh_flags |= SHF_TLS;
2595       if (asect->size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2596         {
2597           struct bfd_link_order *o;
2598
2599           this_hdr->sh_size = 0;
2600           for (o = asect->link_order_head; o != NULL; o = o->next)
2601             if (this_hdr->sh_size < o->offset + o->size)
2602               this_hdr->sh_size = o->offset + o->size;
2603           if (this_hdr->sh_size)
2604             this_hdr->sh_type = SHT_NOBITS;
2605         }
2606     }
2607
2608   /* Check for processor-specific section types.  */
2609   if (bed->elf_backend_fake_sections
2610       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2611     *failedptr = TRUE;
2612
2613   /* If the section has relocs, set up a section header for the
2614      SHT_REL[A] section.  If two relocation sections are required for
2615      this section, it is up to the processor-specific back-end to
2616      create the other.  */
2617   if ((asect->flags & SEC_RELOC) != 0
2618       && !_bfd_elf_init_reloc_shdr (abfd,
2619                                     &elf_section_data (asect)->rel_hdr,
2620                                     asect,
2621                                     asect->use_rela_p))
2622     *failedptr = TRUE;
2623 }
2624
2625 /* Fill in the contents of a SHT_GROUP section.  */
2626
2627 void
2628 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2629 {
2630   bfd_boolean *failedptr = failedptrarg;
2631   unsigned long symindx;
2632   asection *elt, *first;
2633   unsigned char *loc;
2634   struct bfd_link_order *l;
2635   bfd_boolean gas;
2636
2637   if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
2638       || *failedptr)
2639     return;
2640
2641   symindx = 0;
2642   if (elf_group_id (sec) != NULL)
2643     symindx = elf_group_id (sec)->udata.i;
2644
2645   if (symindx == 0)
2646     {
2647       /* If called from the assembler, swap_out_syms will have set up
2648          elf_section_syms;  If called for "ld -r", use target_index.  */
2649       if (elf_section_syms (abfd) != NULL)
2650         symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2651       else
2652         symindx = sec->target_index;
2653     }
2654   elf_section_data (sec)->this_hdr.sh_info = symindx;
2655
2656   /* The contents won't be allocated for "ld -r" or objcopy.  */
2657   gas = TRUE;
2658   if (sec->contents == NULL)
2659     {
2660       gas = FALSE;
2661       sec->contents = bfd_alloc (abfd, sec->size);
2662
2663       /* Arrange for the section to be written out.  */
2664       elf_section_data (sec)->this_hdr.contents = sec->contents;
2665       if (sec->contents == NULL)
2666         {
2667           *failedptr = TRUE;
2668           return;
2669         }
2670     }
2671
2672   loc = sec->contents + sec->size;
2673
2674   /* Get the pointer to the first section in the group that gas
2675      squirreled away here.  objcopy arranges for this to be set to the
2676      start of the input section group.  */
2677   first = elt = elf_next_in_group (sec);
2678
2679   /* First element is a flag word.  Rest of section is elf section
2680      indices for all the sections of the group.  Write them backwards
2681      just to keep the group in the same order as given in .section
2682      directives, not that it matters.  */
2683   while (elt != NULL)
2684     {
2685       asection *s;
2686       unsigned int idx;
2687
2688       loc -= 4;
2689       s = elt;
2690       if (!gas)
2691         s = s->output_section;
2692       idx = 0;
2693       if (s != NULL)
2694         idx = elf_section_data (s)->this_idx;
2695       H_PUT_32 (abfd, idx, loc);
2696       elt = elf_next_in_group (elt);
2697       if (elt == first)
2698         break;
2699     }
2700
2701   /* If this is a relocatable link, then the above did nothing because
2702      SEC is the output section.  Look through the input sections
2703      instead.  */
2704   for (l = sec->link_order_head; l != NULL; l = l->next)
2705     if (l->type == bfd_indirect_link_order
2706         && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2707       do
2708         {
2709           loc -= 4;
2710           H_PUT_32 (abfd,
2711                     elf_section_data (elt->output_section)->this_idx, loc);
2712           elt = elf_next_in_group (elt);
2713           /* During a relocatable link, the lists are circular.  */
2714         }
2715       while (elt != elf_next_in_group (l->u.indirect.section));
2716
2717   if ((loc -= 4) != sec->contents)
2718     abort ();
2719
2720   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2721 }
2722
2723 /* Assign all ELF section numbers.  The dummy first section is handled here
2724    too.  The link/info pointers for the standard section types are filled
2725    in here too, while we're at it.  */
2726
2727 static bfd_boolean
2728 assign_section_numbers (bfd *abfd)
2729 {
2730   struct elf_obj_tdata *t = elf_tdata (abfd);
2731   asection *sec;
2732   unsigned int section_number, secn;
2733   Elf_Internal_Shdr **i_shdrp;
2734   bfd_size_type amt;
2735   struct bfd_elf_section_data *d;
2736
2737   section_number = 1;
2738
2739   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2740
2741   /* Put SHT_GROUP sections first.  */
2742   for (sec = abfd->sections; sec; sec = sec->next)
2743     {
2744       d = elf_section_data (sec);
2745
2746       if (d->this_hdr.sh_type == SHT_GROUP)
2747         {
2748           if (section_number == SHN_LORESERVE)
2749             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2750           d->this_idx = section_number++;
2751         }
2752     }
2753
2754   for (sec = abfd->sections; sec; sec = sec->next)
2755     {
2756       d = elf_section_data (sec);
2757
2758       if (d->this_hdr.sh_type != SHT_GROUP)
2759         {
2760           if (section_number == SHN_LORESERVE)
2761             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2762           d->this_idx = section_number++;
2763         }
2764       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2765       if ((sec->flags & SEC_RELOC) == 0)
2766         d->rel_idx = 0;
2767       else
2768         {
2769           if (section_number == SHN_LORESERVE)
2770             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2771           d->rel_idx = section_number++;
2772           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2773         }
2774
2775       if (d->rel_hdr2)
2776         {
2777           if (section_number == SHN_LORESERVE)
2778             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2779           d->rel_idx2 = section_number++;
2780           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2781         }
2782       else
2783         d->rel_idx2 = 0;
2784     }
2785
2786   if (section_number == SHN_LORESERVE)
2787     section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2788   t->shstrtab_section = section_number++;
2789   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2790   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2791
2792   if (bfd_get_symcount (abfd) > 0)
2793     {
2794       if (section_number == SHN_LORESERVE)
2795         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2796       t->symtab_section = section_number++;
2797       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2798       if (section_number > SHN_LORESERVE - 2)
2799         {
2800           if (section_number == SHN_LORESERVE)
2801             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2802           t->symtab_shndx_section = section_number++;
2803           t->symtab_shndx_hdr.sh_name
2804             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2805                                                   ".symtab_shndx", FALSE);
2806           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2807             return FALSE;
2808         }
2809       if (section_number == SHN_LORESERVE)
2810         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2811       t->strtab_section = section_number++;
2812       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2813     }
2814
2815   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2816   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2817
2818   elf_numsections (abfd) = section_number;
2819   elf_elfheader (abfd)->e_shnum = section_number;
2820   if (section_number > SHN_LORESERVE)
2821     elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2822
2823   /* Set up the list of section header pointers, in agreement with the
2824      indices.  */
2825   amt = section_number * sizeof (Elf_Internal_Shdr *);
2826   i_shdrp = bfd_zalloc (abfd, amt);
2827   if (i_shdrp == NULL)
2828     return FALSE;
2829
2830   amt = sizeof (Elf_Internal_Shdr);
2831   i_shdrp[0] = bfd_zalloc (abfd, amt);
2832   if (i_shdrp[0] == NULL)
2833     {
2834       bfd_release (abfd, i_shdrp);
2835       return FALSE;
2836     }
2837
2838   elf_elfsections (abfd) = i_shdrp;
2839
2840   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2841   if (bfd_get_symcount (abfd) > 0)
2842     {
2843       i_shdrp[t->symtab_section] = &t->symtab_hdr;
2844       if (elf_numsections (abfd) > SHN_LORESERVE)
2845         {
2846           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2847           t->symtab_shndx_hdr.sh_link = t->symtab_section;
2848         }
2849       i_shdrp[t->strtab_section] = &t->strtab_hdr;
2850       t->symtab_hdr.sh_link = t->strtab_section;
2851     }
2852
2853   for (sec = abfd->sections; sec; sec = sec->next)
2854     {
2855       struct bfd_elf_section_data *d = elf_section_data (sec);
2856       asection *s;
2857       const char *name;
2858
2859       i_shdrp[d->this_idx] = &d->this_hdr;
2860       if (d->rel_idx != 0)
2861         i_shdrp[d->rel_idx] = &d->rel_hdr;
2862       if (d->rel_idx2 != 0)
2863         i_shdrp[d->rel_idx2] = d->rel_hdr2;
2864
2865       /* Fill in the sh_link and sh_info fields while we're at it.  */
2866
2867       /* sh_link of a reloc section is the section index of the symbol
2868          table.  sh_info is the section index of the section to which
2869          the relocation entries apply.  */
2870       if (d->rel_idx != 0)
2871         {
2872           d->rel_hdr.sh_link = t->symtab_section;
2873           d->rel_hdr.sh_info = d->this_idx;
2874         }
2875       if (d->rel_idx2 != 0)
2876         {
2877           d->rel_hdr2->sh_link = t->symtab_section;
2878           d->rel_hdr2->sh_info = d->this_idx;
2879         }
2880
2881       /* We need to set up sh_link for SHF_LINK_ORDER.  */
2882       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
2883         {
2884           s = elf_linked_to_section (sec);
2885           if (s)
2886             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2887           else
2888             {
2889               struct bfd_link_order *p;
2890
2891               /* Find out what the corresponding section in output
2892                  is.  */
2893               for (p = sec->link_order_head; p != NULL; p = p->next)
2894                 {
2895                   s = p->u.indirect.section;
2896                   if (p->type == bfd_indirect_link_order
2897                       && (bfd_get_flavour (s->owner)
2898                           == bfd_target_elf_flavour))
2899                     {
2900                       Elf_Internal_Shdr ** const elf_shdrp
2901                         = elf_elfsections (s->owner);
2902                       int elfsec
2903                         = _bfd_elf_section_from_bfd_section (s->owner, s);
2904                       elfsec = elf_shdrp[elfsec]->sh_link;
2905                       /* PR 290:
2906                          The Intel C compiler generates SHT_IA_64_UNWIND with
2907                          SHF_LINK_ORDER.  But it doesn't set theh sh_link or
2908                          sh_info fields.  Hence we could get the situation
2909                          where elfsec is 0.  */
2910                       if (elfsec == 0)
2911                         {
2912                           const struct elf_backend_data *bed
2913                             = get_elf_backend_data (abfd);
2914                           if (bed->link_order_error_handler)
2915                             bed->link_order_error_handler
2916                               (_("%B: warning: sh_link not set for section `%S'"),
2917                                abfd, s);
2918                         }
2919                       else
2920                         {
2921                           s = elf_shdrp[elfsec]->bfd_section->output_section;
2922                           BFD_ASSERT (s != NULL);
2923                           d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2924                         }
2925                       break;
2926                     }
2927                 }
2928             }
2929         }
2930
2931       switch (d->this_hdr.sh_type)
2932         {
2933         case SHT_REL:
2934         case SHT_RELA:
2935           /* A reloc section which we are treating as a normal BFD
2936              section.  sh_link is the section index of the symbol
2937              table.  sh_info is the section index of the section to
2938              which the relocation entries apply.  We assume that an
2939              allocated reloc section uses the dynamic symbol table.
2940              FIXME: How can we be sure?  */
2941           s = bfd_get_section_by_name (abfd, ".dynsym");
2942           if (s != NULL)
2943             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2944
2945           /* We look up the section the relocs apply to by name.  */
2946           name = sec->name;
2947           if (d->this_hdr.sh_type == SHT_REL)
2948             name += 4;
2949           else
2950             name += 5;
2951           s = bfd_get_section_by_name (abfd, name);
2952           if (s != NULL)
2953             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2954           break;
2955
2956         case SHT_STRTAB:
2957           /* We assume that a section named .stab*str is a stabs
2958              string section.  We look for a section with the same name
2959              but without the trailing ``str'', and set its sh_link
2960              field to point to this section.  */
2961           if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
2962               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2963             {
2964               size_t len;
2965               char *alc;
2966
2967               len = strlen (sec->name);
2968               alc = bfd_malloc (len - 2);
2969               if (alc == NULL)
2970                 return FALSE;
2971               memcpy (alc, sec->name, len - 3);
2972               alc[len - 3] = '\0';
2973               s = bfd_get_section_by_name (abfd, alc);
2974               free (alc);
2975               if (s != NULL)
2976                 {
2977                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2978
2979                   /* This is a .stab section.  */
2980                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
2981                     elf_section_data (s)->this_hdr.sh_entsize
2982                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
2983                 }
2984             }
2985           break;
2986
2987         case SHT_DYNAMIC:
2988         case SHT_DYNSYM:
2989         case SHT_GNU_verneed:
2990         case SHT_GNU_verdef:
2991           /* sh_link is the section header index of the string table
2992              used for the dynamic entries, or the symbol table, or the
2993              version strings.  */
2994           s = bfd_get_section_by_name (abfd, ".dynstr");
2995           if (s != NULL)
2996             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2997           break;
2998
2999         case SHT_GNU_LIBLIST:
3000           /* sh_link is the section header index of the prelink library
3001              list
3002              used for the dynamic entries, or the symbol table, or the
3003              version strings.  */
3004           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3005                                              ? ".dynstr" : ".gnu.libstr");
3006           if (s != NULL)
3007             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3008           break;
3009
3010         case SHT_HASH:
3011         case SHT_GNU_versym:
3012           /* sh_link is the section header index of the symbol table
3013              this hash table or version table is for.  */
3014           s = bfd_get_section_by_name (abfd, ".dynsym");
3015           if (s != NULL)
3016             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3017           break;
3018
3019         case SHT_GROUP:
3020           d->this_hdr.sh_link = t->symtab_section;
3021         }
3022     }
3023
3024   for (secn = 1; secn < section_number; ++secn)
3025     if (i_shdrp[secn] == NULL)
3026       i_shdrp[secn] = i_shdrp[0];
3027     else
3028       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3029                                                        i_shdrp[secn]->sh_name);
3030   return TRUE;
3031 }
3032
3033 /* Map symbol from it's internal number to the external number, moving
3034    all local symbols to be at the head of the list.  */
3035
3036 static int
3037 sym_is_global (bfd *abfd, asymbol *sym)
3038 {
3039   /* If the backend has a special mapping, use it.  */
3040   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3041   if (bed->elf_backend_sym_is_global)
3042     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3043
3044   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3045           || bfd_is_und_section (bfd_get_section (sym))
3046           || bfd_is_com_section (bfd_get_section (sym)));
3047 }
3048
3049 static bfd_boolean
3050 elf_map_symbols (bfd *abfd)
3051 {
3052   unsigned int symcount = bfd_get_symcount (abfd);
3053   asymbol **syms = bfd_get_outsymbols (abfd);
3054   asymbol **sect_syms;
3055   unsigned int num_locals = 0;
3056   unsigned int num_globals = 0;
3057   unsigned int num_locals2 = 0;
3058   unsigned int num_globals2 = 0;
3059   int max_index = 0;
3060   unsigned int idx;
3061   asection *asect;
3062   asymbol **new_syms;
3063   bfd_size_type amt;
3064
3065 #ifdef DEBUG
3066   fprintf (stderr, "elf_map_symbols\n");
3067   fflush (stderr);
3068 #endif
3069
3070   for (asect = abfd->sections; asect; asect = asect->next)
3071     {
3072       if (max_index < asect->index)
3073         max_index = asect->index;
3074     }
3075
3076   max_index++;
3077   amt = max_index * sizeof (asymbol *);
3078   sect_syms = bfd_zalloc (abfd, amt);
3079   if (sect_syms == NULL)
3080     return FALSE;
3081   elf_section_syms (abfd) = sect_syms;
3082   elf_num_section_syms (abfd) = max_index;
3083
3084   /* Init sect_syms entries for any section symbols we have already
3085      decided to output.  */
3086   for (idx = 0; idx < symcount; idx++)
3087     {
3088       asymbol *sym = syms[idx];
3089
3090       if ((sym->flags & BSF_SECTION_SYM) != 0
3091           && sym->value == 0)
3092         {
3093           asection *sec;
3094
3095           sec = sym->section;
3096
3097           if (sec->owner != NULL)
3098             {
3099               if (sec->owner != abfd)
3100                 {
3101                   if (sec->output_offset != 0)
3102                     continue;
3103
3104                   sec = sec->output_section;
3105
3106                   /* Empty sections in the input files may have had a
3107                      section symbol created for them.  (See the comment
3108                      near the end of _bfd_generic_link_output_symbols in
3109                      linker.c).  If the linker script discards such
3110                      sections then we will reach this point.  Since we know
3111                      that we cannot avoid this case, we detect it and skip
3112                      the abort and the assignment to the sect_syms array.
3113                      To reproduce this particular case try running the
3114                      linker testsuite test ld-scripts/weak.exp for an ELF
3115                      port that uses the generic linker.  */
3116                   if (sec->owner == NULL)
3117                     continue;
3118
3119                   BFD_ASSERT (sec->owner == abfd);
3120                 }
3121               sect_syms[sec->index] = syms[idx];
3122             }
3123         }
3124     }
3125
3126   /* Classify all of the symbols.  */
3127   for (idx = 0; idx < symcount; idx++)
3128     {
3129       if (!sym_is_global (abfd, syms[idx]))
3130         num_locals++;
3131       else
3132         num_globals++;
3133     }
3134
3135   /* We will be adding a section symbol for each BFD section.  Most normal
3136      sections will already have a section symbol in outsymbols, but
3137      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3138      at least in that case.  */
3139   for (asect = abfd->sections; asect; asect = asect->next)
3140     {
3141       if (sect_syms[asect->index] == NULL)
3142         {
3143           if (!sym_is_global (abfd, asect->symbol))
3144             num_locals++;
3145           else
3146             num_globals++;
3147         }
3148     }
3149
3150   /* Now sort the symbols so the local symbols are first.  */
3151   amt = (num_locals + num_globals) * sizeof (asymbol *);
3152   new_syms = bfd_alloc (abfd, amt);
3153
3154   if (new_syms == NULL)
3155     return FALSE;
3156
3157   for (idx = 0; idx < symcount; idx++)
3158     {
3159       asymbol *sym = syms[idx];
3160       unsigned int i;
3161
3162       if (!sym_is_global (abfd, sym))
3163         i = num_locals2++;
3164       else
3165         i = num_locals + num_globals2++;
3166       new_syms[i] = sym;
3167       sym->udata.i = i + 1;
3168     }
3169   for (asect = abfd->sections; asect; asect = asect->next)
3170     {
3171       if (sect_syms[asect->index] == NULL)
3172         {
3173           asymbol *sym = asect->symbol;
3174           unsigned int i;
3175
3176           sect_syms[asect->index] = sym;
3177           if (!sym_is_global (abfd, sym))
3178             i = num_locals2++;
3179           else
3180             i = num_locals + num_globals2++;
3181           new_syms[i] = sym;
3182           sym->udata.i = i + 1;
3183         }
3184     }
3185
3186   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3187
3188   elf_num_locals (abfd) = num_locals;
3189   elf_num_globals (abfd) = num_globals;
3190   return TRUE;
3191 }
3192
3193 /* Align to the maximum file alignment that could be required for any
3194    ELF data structure.  */
3195
3196 static inline file_ptr
3197 align_file_position (file_ptr off, int align)
3198 {
3199   return (off + align - 1) & ~(align - 1);
3200 }
3201
3202 /* Assign a file position to a section, optionally aligning to the
3203    required section alignment.  */
3204
3205 file_ptr
3206 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3207                                            file_ptr offset,
3208                                            bfd_boolean align)
3209 {
3210   if (align)
3211     {
3212       unsigned int al;
3213
3214       al = i_shdrp->sh_addralign;
3215       if (al > 1)
3216         offset = BFD_ALIGN (offset, al);
3217     }
3218   i_shdrp->sh_offset = offset;
3219   if (i_shdrp->bfd_section != NULL)
3220     i_shdrp->bfd_section->filepos = offset;
3221   if (i_shdrp->sh_type != SHT_NOBITS)
3222     offset += i_shdrp->sh_size;
3223   return offset;
3224 }
3225
3226 /* Compute the file positions we are going to put the sections at, and
3227    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3228    is not NULL, this is being called by the ELF backend linker.  */
3229
3230 bfd_boolean
3231 _bfd_elf_compute_section_file_positions (bfd *abfd,
3232                                          struct bfd_link_info *link_info)
3233 {
3234   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3235   bfd_boolean failed;
3236   struct bfd_strtab_hash *strtab;
3237   Elf_Internal_Shdr *shstrtab_hdr;
3238
3239   if (abfd->output_has_begun)
3240     return TRUE;
3241
3242   /* Do any elf backend specific processing first.  */
3243   if (bed->elf_backend_begin_write_processing)
3244     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3245
3246   if (! prep_headers (abfd))
3247     return FALSE;
3248
3249   /* Post process the headers if necessary.  */
3250   if (bed->elf_backend_post_process_headers)
3251     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3252
3253   failed = FALSE;
3254   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3255   if (failed)
3256     return FALSE;
3257
3258   if (!assign_section_numbers (abfd))
3259     return FALSE;
3260
3261   /* The backend linker builds symbol table information itself.  */
3262   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3263     {
3264       /* Non-zero if doing a relocatable link.  */
3265       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3266
3267       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3268         return FALSE;
3269     }
3270
3271   if (link_info == NULL)
3272     {
3273       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3274       if (failed)
3275         return FALSE;
3276     }
3277
3278   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3279   /* sh_name was set in prep_headers.  */
3280   shstrtab_hdr->sh_type = SHT_STRTAB;
3281   shstrtab_hdr->sh_flags = 0;
3282   shstrtab_hdr->sh_addr = 0;
3283   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3284   shstrtab_hdr->sh_entsize = 0;
3285   shstrtab_hdr->sh_link = 0;
3286   shstrtab_hdr->sh_info = 0;
3287   /* sh_offset is set in assign_file_positions_except_relocs.  */
3288   shstrtab_hdr->sh_addralign = 1;
3289
3290   if (!assign_file_positions_except_relocs (abfd, link_info))
3291     return FALSE;
3292
3293   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3294     {
3295       file_ptr off;
3296       Elf_Internal_Shdr *hdr;
3297
3298       off = elf_tdata (abfd)->next_file_pos;
3299
3300       hdr = &elf_tdata (abfd)->symtab_hdr;
3301       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3302
3303       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3304       if (hdr->sh_size != 0)
3305         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3306
3307       hdr = &elf_tdata (abfd)->strtab_hdr;
3308       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3309
3310       elf_tdata (abfd)->next_file_pos = off;
3311
3312       /* Now that we know where the .strtab section goes, write it
3313          out.  */
3314       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3315           || ! _bfd_stringtab_emit (abfd, strtab))
3316         return FALSE;
3317       _bfd_stringtab_free (strtab);
3318     }
3319
3320   abfd->output_has_begun = TRUE;
3321
3322   return TRUE;
3323 }
3324
3325 /* Create a mapping from a set of sections to a program segment.  */
3326
3327 static struct elf_segment_map *
3328 make_mapping (bfd *abfd,
3329               asection **sections,
3330               unsigned int from,
3331               unsigned int to,
3332               bfd_boolean phdr)
3333 {
3334   struct elf_segment_map *m;
3335   unsigned int i;
3336   asection **hdrpp;
3337   bfd_size_type amt;
3338
3339   amt = sizeof (struct elf_segment_map);
3340   amt += (to - from - 1) * sizeof (asection *);
3341   m = bfd_zalloc (abfd, amt);
3342   if (m == NULL)
3343     return NULL;
3344   m->next = NULL;
3345   m->p_type = PT_LOAD;
3346   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3347     m->sections[i - from] = *hdrpp;
3348   m->count = to - from;
3349
3350   if (from == 0 && phdr)
3351     {
3352       /* Include the headers in the first PT_LOAD segment.  */
3353       m->includes_filehdr = 1;
3354       m->includes_phdrs = 1;
3355     }
3356
3357   return m;
3358 }
3359
3360 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
3361    on failure.  */
3362
3363 struct elf_segment_map *
3364 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3365 {
3366   struct elf_segment_map *m;
3367
3368   m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3369   if (m == NULL)
3370     return NULL;
3371   m->next = NULL;
3372   m->p_type = PT_DYNAMIC;
3373   m->count = 1;
3374   m->sections[0] = dynsec;
3375
3376   return m;
3377 }
3378
3379 /* Set up a mapping from BFD sections to program segments.  */
3380
3381 static bfd_boolean
3382 map_sections_to_segments (bfd *abfd)
3383 {
3384   asection **sections = NULL;
3385   asection *s;
3386   unsigned int i;
3387   unsigned int count;
3388   struct elf_segment_map *mfirst;
3389   struct elf_segment_map **pm;
3390   struct elf_segment_map *m;
3391   asection *last_hdr;
3392   bfd_vma last_size;
3393   unsigned int phdr_index;
3394   bfd_vma maxpagesize;
3395   asection **hdrpp;
3396   bfd_boolean phdr_in_segment = TRUE;
3397   bfd_boolean writable;
3398   int tls_count = 0;
3399   asection *first_tls = NULL;
3400   asection *dynsec, *eh_frame_hdr;
3401   bfd_size_type amt;
3402
3403   if (elf_tdata (abfd)->segment_map != NULL)
3404     return TRUE;
3405
3406   if (bfd_count_sections (abfd) == 0)
3407     return TRUE;
3408
3409   /* Select the allocated sections, and sort them.  */
3410
3411   amt = bfd_count_sections (abfd) * sizeof (asection *);
3412   sections = bfd_malloc (amt);
3413   if (sections == NULL)
3414     goto error_return;
3415
3416   i = 0;
3417   for (s = abfd->sections; s != NULL; s = s->next)
3418     {
3419       if ((s->flags & SEC_ALLOC) != 0)
3420         {
3421           sections[i] = s;
3422           ++i;
3423         }
3424     }
3425   BFD_ASSERT (i <= bfd_count_sections (abfd));
3426   count = i;
3427
3428   qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3429
3430   /* Build the mapping.  */
3431
3432   mfirst = NULL;
3433   pm = &mfirst;
3434
3435   /* If we have a .interp section, then create a PT_PHDR segment for
3436      the program headers and a PT_INTERP segment for the .interp
3437      section.  */
3438   s = bfd_get_section_by_name (abfd, ".interp");
3439   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3440     {
3441       amt = sizeof (struct elf_segment_map);
3442       m = bfd_zalloc (abfd, amt);
3443       if (m == NULL)
3444         goto error_return;
3445       m->next = NULL;
3446       m->p_type = PT_PHDR;
3447       /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3448       m->p_flags = PF_R | PF_X;
3449       m->p_flags_valid = 1;
3450       m->includes_phdrs = 1;
3451
3452       *pm = m;
3453       pm = &m->next;
3454
3455       amt = sizeof (struct elf_segment_map);
3456       m = bfd_zalloc (abfd, amt);
3457       if (m == NULL)
3458         goto error_return;
3459       m->next = NULL;
3460       m->p_type = PT_INTERP;
3461       m->count = 1;
3462       m->sections[0] = s;
3463
3464       *pm = m;
3465       pm = &m->next;
3466     }
3467
3468   /* Look through the sections.  We put sections in the same program
3469      segment when the start of the second section can be placed within
3470      a few bytes of the end of the first section.  */
3471   last_hdr = NULL;
3472   last_size = 0;
3473   phdr_index = 0;
3474   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3475   writable = FALSE;
3476   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3477   if (dynsec != NULL
3478       && (dynsec->flags & SEC_LOAD) == 0)
3479     dynsec = NULL;
3480
3481   /* Deal with -Ttext or something similar such that the first section
3482      is not adjacent to the program headers.  This is an
3483      approximation, since at this point we don't know exactly how many
3484      program headers we will need.  */
3485   if (count > 0)
3486     {
3487       bfd_size_type phdr_size;
3488
3489       phdr_size = elf_tdata (abfd)->program_header_size;
3490       if (phdr_size == 0)
3491         phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3492       if ((abfd->flags & D_PAGED) == 0
3493           || sections[0]->lma < phdr_size
3494           || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3495         phdr_in_segment = FALSE;
3496     }
3497
3498   for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3499     {
3500       asection *hdr;
3501       bfd_boolean new_segment;
3502
3503       hdr = *hdrpp;
3504
3505       /* See if this section and the last one will fit in the same
3506          segment.  */
3507
3508       if (last_hdr == NULL)
3509         {
3510           /* If we don't have a segment yet, then we don't need a new
3511              one (we build the last one after this loop).  */
3512           new_segment = FALSE;
3513         }
3514       else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3515         {
3516           /* If this section has a different relation between the
3517              virtual address and the load address, then we need a new
3518              segment.  */
3519           new_segment = TRUE;
3520         }
3521       else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3522                < BFD_ALIGN (hdr->lma, maxpagesize))
3523         {
3524           /* If putting this section in this segment would force us to
3525              skip a page in the segment, then we need a new segment.  */
3526           new_segment = TRUE;
3527         }
3528       else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3529                && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3530         {
3531           /* We don't want to put a loadable section after a
3532              nonloadable section in the same segment.
3533              Consider .tbss sections as loadable for this purpose.  */
3534           new_segment = TRUE;
3535         }
3536       else if ((abfd->flags & D_PAGED) == 0)
3537         {
3538           /* If the file is not demand paged, which means that we
3539              don't require the sections to be correctly aligned in the
3540              file, then there is no other reason for a new segment.  */
3541           new_segment = FALSE;
3542         }
3543       else if (! writable
3544                && (hdr->flags & SEC_READONLY) == 0
3545                && (((last_hdr->lma + last_size - 1)
3546                     & ~(maxpagesize - 1))
3547                    != (hdr->lma & ~(maxpagesize - 1))))
3548         {
3549           /* We don't want to put a writable section in a read only
3550              segment, unless they are on the same page in memory
3551              anyhow.  We already know that the last section does not
3552              bring us past the current section on the page, so the
3553              only case in which the new section is not on the same
3554              page as the previous section is when the previous section
3555              ends precisely on a page boundary.  */
3556           new_segment = TRUE;
3557         }
3558       else
3559         {
3560           /* Otherwise, we can use the same segment.  */
3561           new_segment = FALSE;
3562         }
3563
3564       if (! new_segment)
3565         {
3566           if ((hdr->flags & SEC_READONLY) == 0)
3567             writable = TRUE;
3568           last_hdr = hdr;
3569           /* .tbss sections effectively have zero size.  */
3570           if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3571             last_size = hdr->size;
3572           else
3573             last_size = 0;
3574           continue;
3575         }
3576
3577       /* We need a new program segment.  We must create a new program
3578          header holding all the sections from phdr_index until hdr.  */
3579
3580       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3581       if (m == NULL)
3582         goto error_return;
3583
3584       *pm = m;
3585       pm = &m->next;
3586
3587       if ((hdr->flags & SEC_READONLY) == 0)
3588         writable = TRUE;
3589       else
3590         writable = FALSE;
3591
3592       last_hdr = hdr;
3593       /* .tbss sections effectively have zero size.  */
3594       if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3595         last_size = hdr->size;
3596       else
3597         last_size = 0;
3598       phdr_index = i;
3599       phdr_in_segment = FALSE;
3600     }
3601
3602   /* Create a final PT_LOAD program segment.  */
3603   if (last_hdr != NULL)
3604     {
3605       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3606       if (m == NULL)
3607         goto error_return;
3608
3609       *pm = m;
3610       pm = &m->next;
3611     }
3612
3613   /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
3614   if (dynsec != NULL)
3615     {
3616       m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3617       if (m == NULL)
3618         goto error_return;
3619       *pm = m;
3620       pm = &m->next;
3621     }
3622
3623   /* For each loadable .note section, add a PT_NOTE segment.  We don't
3624      use bfd_get_section_by_name, because if we link together
3625      nonloadable .note sections and loadable .note sections, we will
3626      generate two .note sections in the output file.  FIXME: Using
3627      names for section types is bogus anyhow.  */
3628   for (s = abfd->sections; s != NULL; s = s->next)
3629     {
3630       if ((s->flags & SEC_LOAD) != 0
3631           && strncmp (s->name, ".note", 5) == 0)
3632         {
3633           amt = sizeof (struct elf_segment_map);
3634           m = bfd_zalloc (abfd, amt);
3635           if (m == NULL)
3636             goto error_return;
3637           m->next = NULL;
3638           m->p_type = PT_NOTE;
3639           m->count = 1;
3640           m->sections[0] = s;
3641
3642           *pm = m;
3643           pm = &m->next;
3644         }
3645       if (s->flags & SEC_THREAD_LOCAL)
3646         {
3647           if (! tls_count)
3648             first_tls = s;
3649           tls_count++;
3650         }
3651     }
3652
3653   /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
3654   if (tls_count > 0)
3655     {
3656       int i;
3657
3658       amt = sizeof (struct elf_segment_map);
3659       amt += (tls_count - 1) * sizeof (asection *);
3660       m = bfd_zalloc (abfd, amt);
3661       if (m == NULL)
3662         goto error_return;
3663       m->next = NULL;
3664       m->p_type = PT_TLS;
3665       m->count = tls_count;
3666       /* Mandated PF_R.  */
3667       m->p_flags = PF_R;
3668       m->p_flags_valid = 1;
3669       for (i = 0; i < tls_count; ++i)
3670         {
3671           BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3672           m->sections[i] = first_tls;
3673           first_tls = first_tls->next;
3674         }
3675
3676       *pm = m;
3677       pm = &m->next;
3678     }
3679
3680   /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3681      segment.  */
3682   eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3683   if (eh_frame_hdr != NULL
3684       && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3685     {
3686       amt = sizeof (struct elf_segment_map);
3687       m = bfd_zalloc (abfd, amt);
3688       if (m == NULL)
3689         goto error_return;
3690       m->next = NULL;
3691       m->p_type = PT_GNU_EH_FRAME;
3692       m->count = 1;
3693       m->sections[0] = eh_frame_hdr->output_section;
3694
3695       *pm = m;
3696       pm = &m->next;
3697     }
3698
3699   if (elf_tdata (abfd)->stack_flags)
3700     {
3701       amt = sizeof (struct elf_segment_map);
3702       m = bfd_zalloc (abfd, amt);
3703       if (m == NULL)
3704         goto error_return;
3705       m->next = NULL;
3706       m->p_type = PT_GNU_STACK;
3707       m->p_flags = elf_tdata (abfd)->stack_flags;
3708       m->p_flags_valid = 1;
3709
3710       *pm = m;
3711       pm = &m->next;
3712     }
3713
3714   if (elf_tdata (abfd)->relro)
3715     {
3716       amt = sizeof (struct elf_segment_map);
3717       m = bfd_zalloc (abfd, amt);
3718       if (m == NULL)
3719         goto error_return;
3720       m->next = NULL;
3721       m->p_type = PT_GNU_RELRO;
3722       m->p_flags = PF_R;
3723       m->p_flags_valid = 1;
3724
3725       *pm = m;
3726       pm = &m->next;
3727     }
3728
3729   free (sections);
3730   sections = NULL;
3731
3732   elf_tdata (abfd)->segment_map = mfirst;
3733   return TRUE;
3734
3735  error_return:
3736   if (sections != NULL)
3737     free (sections);
3738   return FALSE;
3739 }
3740
3741 /* Sort sections by address.  */
3742
3743 static int
3744 elf_sort_sections (const void *arg1, const void *arg2)
3745 {
3746   const asection *sec1 = *(const asection **) arg1;
3747   const asection *sec2 = *(const asection **) arg2;
3748   bfd_size_type size1, size2;
3749
3750   /* Sort by LMA first, since this is the address used to
3751      place the section into a segment.  */
3752   if (sec1->lma < sec2->lma)
3753     return -1;
3754   else if (sec1->lma > sec2->lma)
3755     return 1;
3756
3757   /* Then sort by VMA.  Normally the LMA and the VMA will be
3758      the same, and this will do nothing.  */
3759   if (sec1->vma < sec2->vma)
3760     return -1;
3761   else if (sec1->vma > sec2->vma)
3762     return 1;
3763
3764   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
3765
3766 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3767
3768   if (TOEND (sec1))
3769     {
3770       if (TOEND (sec2))
3771         {
3772           /* If the indicies are the same, do not return 0
3773              here, but continue to try the next comparison.  */
3774           if (sec1->target_index - sec2->target_index != 0)
3775             return sec1->target_index - sec2->target_index;
3776         }
3777       else
3778         return 1;
3779     }
3780   else if (TOEND (sec2))
3781     return -1;
3782
3783 #undef TOEND
3784
3785   /* Sort by size, to put zero sized sections
3786      before others at the same address.  */
3787
3788   size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
3789   size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
3790
3791   if (size1 < size2)
3792     return -1;
3793   if (size1 > size2)
3794     return 1;
3795
3796   return sec1->target_index - sec2->target_index;
3797 }
3798
3799 /* Ian Lance Taylor writes:
3800
3801    We shouldn't be using % with a negative signed number.  That's just
3802    not good.  We have to make sure either that the number is not
3803    negative, or that the number has an unsigned type.  When the types
3804    are all the same size they wind up as unsigned.  When file_ptr is a
3805    larger signed type, the arithmetic winds up as signed long long,
3806    which is wrong.
3807
3808    What we're trying to say here is something like ``increase OFF by
3809    the least amount that will cause it to be equal to the VMA modulo
3810    the page size.''  */
3811 /* In other words, something like:
3812
3813    vma_offset = m->sections[0]->vma % bed->maxpagesize;
3814    off_offset = off % bed->maxpagesize;
3815    if (vma_offset < off_offset)
3816      adjustment = vma_offset + bed->maxpagesize - off_offset;
3817    else
3818      adjustment = vma_offset - off_offset;
3819
3820    which can can be collapsed into the expression below.  */
3821
3822 static file_ptr
3823 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
3824 {
3825   return ((vma - off) % maxpagesize);
3826 }
3827
3828 /* Assign file positions to the sections based on the mapping from
3829    sections to segments.  This function also sets up some fields in
3830    the file header, and writes out the program headers.  */
3831
3832 static bfd_boolean
3833 assign_file_positions_for_segments (bfd *abfd, struct bfd_link_info *link_info)
3834 {
3835   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3836   unsigned int count;
3837   struct elf_segment_map *m;
3838   unsigned int alloc;
3839   Elf_Internal_Phdr *phdrs;
3840   file_ptr off, voff;
3841   bfd_vma filehdr_vaddr, filehdr_paddr;
3842   bfd_vma phdrs_vaddr, phdrs_paddr;
3843   Elf_Internal_Phdr *p;
3844   bfd_size_type amt;
3845
3846   if (elf_tdata (abfd)->segment_map == NULL)
3847     {
3848       if (! map_sections_to_segments (abfd))
3849         return FALSE;
3850     }
3851   else
3852     {
3853       /* The placement algorithm assumes that non allocated sections are
3854          not in PT_LOAD segments.  We ensure this here by removing such
3855          sections from the segment map.  */
3856       for (m = elf_tdata (abfd)->segment_map;
3857            m != NULL;
3858            m = m->next)
3859         {
3860           unsigned int new_count;
3861           unsigned int i;
3862
3863           if (m->p_type != PT_LOAD)
3864             continue;
3865
3866           new_count = 0;
3867           for (i = 0; i < m->count; i ++)
3868             {
3869               if ((m->sections[i]->flags & SEC_ALLOC) != 0)
3870                 {
3871                   if (i != new_count)
3872                     m->sections[new_count] = m->sections[i];
3873
3874                   new_count ++;
3875                 }
3876             }
3877
3878           if (new_count != m->count)
3879             m->count = new_count;
3880         }
3881     }
3882
3883   if (bed->elf_backend_modify_segment_map)
3884     {
3885       if (! (*bed->elf_backend_modify_segment_map) (abfd, link_info))
3886         return FALSE;
3887     }
3888
3889   count = 0;
3890   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3891     ++count;
3892
3893   elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3894   elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3895   elf_elfheader (abfd)->e_phnum = count;
3896
3897   if (count == 0)
3898     {
3899       elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
3900       return TRUE;
3901     }
3902
3903   /* If we already counted the number of program segments, make sure
3904      that we allocated enough space.  This happens when SIZEOF_HEADERS
3905      is used in a linker script.  */
3906   alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3907   if (alloc != 0 && count > alloc)
3908     {
3909       ((*_bfd_error_handler)
3910        (_("%B: Not enough room for program headers (allocated %u, need %u)"),
3911         abfd, alloc, count));
3912       bfd_set_error (bfd_error_bad_value);
3913       return FALSE;
3914     }
3915
3916   if (alloc == 0)
3917     alloc = count;
3918
3919   amt = alloc * sizeof (Elf_Internal_Phdr);
3920   phdrs = bfd_alloc (abfd, amt);
3921   if (phdrs == NULL)
3922     return FALSE;
3923
3924   off = bed->s->sizeof_ehdr;
3925   off += alloc * bed->s->sizeof_phdr;
3926
3927   filehdr_vaddr = 0;
3928   filehdr_paddr = 0;
3929   phdrs_vaddr = 0;
3930   phdrs_paddr = 0;
3931
3932   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3933        m != NULL;
3934        m = m->next, p++)
3935     {
3936       unsigned int i;
3937       asection **secpp;
3938
3939       /* If elf_segment_map is not from map_sections_to_segments, the
3940          sections may not be correctly ordered.  NOTE: sorting should
3941          not be done to the PT_NOTE section of a corefile, which may
3942          contain several pseudo-sections artificially created by bfd.
3943          Sorting these pseudo-sections breaks things badly.  */
3944       if (m->count > 1
3945           && !(elf_elfheader (abfd)->e_type == ET_CORE
3946                && m->p_type == PT_NOTE))
3947         qsort (m->sections, (size_t) m->count, sizeof (asection *),
3948                elf_sort_sections);
3949
3950       /* An ELF segment (described by Elf_Internal_Phdr) may contain a
3951          number of sections with contents contributing to both p_filesz
3952          and p_memsz, followed by a number of sections with no contents
3953          that just contribute to p_memsz.  In this loop, OFF tracks next
3954          available file offset for PT_LOAD and PT_NOTE segments.  VOFF is
3955          an adjustment we use for segments that have no file contents
3956          but need zero filled memory allocation.  */
3957       voff = 0;
3958       p->p_type = m->p_type;
3959       p->p_flags = m->p_flags;
3960
3961       if (p->p_type == PT_LOAD
3962           && m->count > 0)
3963         {
3964           bfd_size_type align;
3965           bfd_vma adjust;
3966
3967           if ((abfd->flags & D_PAGED) != 0)
3968             align = bed->maxpagesize;
3969           else
3970             {
3971               unsigned int align_power = 0;
3972               for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3973                 {
3974                   unsigned int secalign;
3975
3976                   secalign = bfd_get_section_alignment (abfd, *secpp);
3977                   if (secalign > align_power)
3978                     align_power = secalign;
3979                 }
3980               align = (bfd_size_type) 1 << align_power;
3981             }
3982
3983           adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
3984           off += adjust;
3985           if (adjust != 0
3986               && !m->includes_filehdr
3987               && !m->includes_phdrs
3988               && (ufile_ptr) off >= align)
3989             {
3990               /* If the first section isn't loadable, the same holds for
3991                  any other sections.  Since the segment won't need file
3992                  space, we can make p_offset overlap some prior segment.
3993                  However, .tbss is special.  If a segment starts with
3994                  .tbss, we need to look at the next section to decide
3995                  whether the segment has any loadable sections.  */
3996               i = 0;
3997               while ((m->sections[i]->flags & SEC_LOAD) == 0)
3998                 {
3999                   if ((m->sections[i]->flags & SEC_THREAD_LOCAL) == 0
4000                       || ++i >= m->count)
4001                     {
4002                       off -= adjust;
4003                       voff = adjust - align;
4004                       break;
4005                     }
4006                 }
4007             }
4008         }
4009       /* Make sure the .dynamic section is the first section in the
4010          PT_DYNAMIC segment.  */
4011       else if (p->p_type == PT_DYNAMIC
4012                && m->count > 1
4013                && strcmp (m->sections[0]->name, ".dynamic") != 0)
4014         {
4015           _bfd_error_handler
4016             (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4017              abfd);
4018           bfd_set_error (bfd_error_bad_value);
4019           return FALSE;
4020         }
4021
4022       if (m->count == 0)
4023         p->p_vaddr = 0;
4024       else
4025         p->p_vaddr = m->sections[0]->vma;
4026
4027       if (m->p_paddr_valid)
4028         p->p_paddr = m->p_paddr;
4029       else if (m->count == 0)
4030         p->p_paddr = 0;
4031       else
4032         p->p_paddr = m->sections[0]->lma;
4033
4034       if (p->p_type == PT_LOAD
4035           && (abfd->flags & D_PAGED) != 0)
4036         p->p_align = bed->maxpagesize;
4037       else if (m->count == 0)
4038         p->p_align = 1 << bed->s->log_file_align;
4039       else
4040         p->p_align = 0;
4041
4042       p->p_offset = 0;
4043       p->p_filesz = 0;
4044       p->p_memsz = 0;
4045
4046       if (m->includes_filehdr)
4047         {
4048           if (! m->p_flags_valid)
4049             p->p_flags |= PF_R;
4050           p->p_offset = 0;
4051           p->p_filesz = bed->s->sizeof_ehdr;
4052           p->p_memsz = bed->s->sizeof_ehdr;
4053           if (m->count > 0)
4054             {
4055               BFD_ASSERT (p->p_type == PT_LOAD);
4056
4057               if (p->p_vaddr < (bfd_vma) off)
4058                 {
4059                   (*_bfd_error_handler)
4060                     (_("%B: Not enough room for program headers, try linking with -N"),
4061                      abfd);
4062                   bfd_set_error (bfd_error_bad_value);
4063                   return FALSE;
4064                 }
4065
4066               p->p_vaddr -= off;
4067               if (! m->p_paddr_valid)
4068                 p->p_paddr -= off;
4069             }
4070           if (p->p_type == PT_LOAD)
4071             {
4072               filehdr_vaddr = p->p_vaddr;
4073               filehdr_paddr = p->p_paddr;
4074             }
4075         }
4076
4077       if (m->includes_phdrs)
4078         {
4079           if (! m->p_flags_valid)
4080             p->p_flags |= PF_R;
4081
4082           if (m->includes_filehdr)
4083             {
4084               if (p->p_type == PT_LOAD)
4085                 {
4086                   phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
4087                   phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
4088                 }
4089             }
4090           else
4091             {
4092               p->p_offset = bed->s->sizeof_ehdr;
4093
4094               if (m->count > 0)
4095                 {
4096                   BFD_ASSERT (p->p_type == PT_LOAD);
4097                   p->p_vaddr -= off - p->p_offset;
4098                   if (! m->p_paddr_valid)
4099                     p->p_paddr -= off - p->p_offset;
4100                 }
4101
4102               if (p->p_type == PT_LOAD)
4103                 {
4104                   phdrs_vaddr = p->p_vaddr;
4105                   phdrs_paddr = p->p_paddr;
4106                 }
4107               else
4108                 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4109             }
4110
4111           p->p_filesz += alloc * bed->s->sizeof_phdr;
4112           p->p_memsz += alloc * bed->s->sizeof_phdr;
4113         }
4114
4115       if (p->p_type == PT_LOAD
4116           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4117         {
4118           if (! m->includes_filehdr && ! m->includes_phdrs)
4119             p->p_offset = off + voff;
4120           else
4121             {
4122               file_ptr adjust;
4123
4124               adjust = off - (p->p_offset + p->p_filesz);
4125               p->p_filesz += adjust;
4126               p->p_memsz += adjust;
4127             }
4128         }
4129
4130       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4131         {
4132           asection *sec;
4133           flagword flags;
4134           bfd_size_type align;
4135
4136           sec = *secpp;
4137           flags = sec->flags;
4138           align = 1 << bfd_get_section_alignment (abfd, sec);
4139
4140           if (p->p_type == PT_LOAD
4141               || p->p_type == PT_TLS)
4142             {
4143               bfd_signed_vma adjust;
4144
4145               if ((flags & SEC_LOAD) != 0)
4146                 {
4147                   adjust = sec->lma - (p->p_paddr + p->p_filesz);
4148                   if (adjust < 0)
4149                     {
4150                       (*_bfd_error_handler)
4151                         (_("%B: section %A lma 0x%lx overlaps previous sections"),
4152                          abfd, sec, (unsigned long) sec->lma);
4153                       adjust = 0;
4154                     }
4155                   off += adjust;
4156                   p->p_filesz += adjust;
4157                   p->p_memsz += adjust;
4158                 }
4159               /* .tbss is special.  It doesn't contribute to p_memsz of
4160                  normal segments.  */
4161               else if ((flags & SEC_THREAD_LOCAL) == 0
4162                        || p->p_type == PT_TLS)
4163                 {
4164                   /* The section VMA must equal the file position
4165                      modulo the page size.  */
4166                   bfd_size_type page = align;
4167                   if ((abfd->flags & D_PAGED) != 0)
4168                     page = bed->maxpagesize;
4169                   adjust = vma_page_aligned_bias (sec->vma,
4170                                                   p->p_vaddr + p->p_memsz,
4171                                                   page);
4172                   p->p_memsz += adjust;
4173                 }
4174             }
4175
4176           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4177             {
4178               /* The section at i == 0 is the one that actually contains
4179                  everything.  */
4180               if (i == 0)
4181                 {
4182                   sec->filepos = off;
4183                   off += sec->size;
4184                   p->p_filesz = sec->size;
4185                   p->p_memsz = 0;
4186                   p->p_align = 1;
4187                 }
4188               else
4189                 {
4190                   /* The rest are fake sections that shouldn't be written.  */
4191                   sec->filepos = 0;
4192                   sec->size = 0;
4193                   sec->flags = 0;
4194                   continue;
4195                 }
4196             }
4197           else
4198             {
4199               if (p->p_type == PT_LOAD)
4200                 {
4201                   sec->filepos = off;
4202                   /* FIXME: The SEC_HAS_CONTENTS test here dates back to
4203                      1997, and the exact reason for it isn't clear.  One
4204                      plausible explanation is that it is to work around
4205                      a problem we have with linker scripts using data
4206                      statements in NOLOAD sections.  I don't think it
4207                      makes a great deal of sense to have such a section
4208                      assigned to a PT_LOAD segment, but apparently
4209                      people do this.  The data statement results in a
4210                      bfd_data_link_order being built, and these need
4211                      section contents to write into.  Eventually, we get
4212                      to _bfd_elf_write_object_contents which writes any
4213                      section with contents to the output.  Make room
4214                      here for the write, so that following segments are
4215                      not trashed.  */
4216                   if ((flags & SEC_LOAD) != 0
4217                       || (flags & SEC_HAS_CONTENTS) != 0)
4218                     off += sec->size;
4219                 }
4220
4221               if ((flags & SEC_LOAD) != 0)
4222                 {
4223                   p->p_filesz += sec->size;
4224                   p->p_memsz += 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   char *outbound_syms;
5580   char *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, char *, 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 }