bfd/elf.c

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