bfd/elf.c

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