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