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
2729   section_number = 1;
2730
2731   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2732
2733   for (sec = abfd->sections; sec; sec = sec->next)
2734     {
2735       struct bfd_elf_section_data *d = elf_section_data (sec);
2736
2737       if (section_number == SHN_LORESERVE)
2738         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2739       d->this_idx = section_number++;
2740       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2741       if ((sec->flags & SEC_RELOC) == 0)
2742         d->rel_idx = 0;
2743       else
2744         {
2745           if (section_number == SHN_LORESERVE)
2746             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2747           d->rel_idx = section_number++;
2748           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2749         }
2750
2751       if (d->rel_hdr2)
2752         {
2753           if (section_number == SHN_LORESERVE)
2754             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2755           d->rel_idx2 = section_number++;
2756           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2757         }
2758       else
2759         d->rel_idx2 = 0;
2760     }
2761
2762   if (section_number == SHN_LORESERVE)
2763     section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2764   t->shstrtab_section = section_number++;
2765   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2766   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2767
2768   if (bfd_get_symcount (abfd) > 0)
2769     {
2770       if (section_number == SHN_LORESERVE)
2771         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2772       t->symtab_section = section_number++;
2773       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2774       if (section_number > SHN_LORESERVE - 2)
2775         {
2776           if (section_number == SHN_LORESERVE)
2777             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2778           t->symtab_shndx_section = section_number++;
2779           t->symtab_shndx_hdr.sh_name
2780             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2781                                                   ".symtab_shndx", FALSE);
2782           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2783             return FALSE;
2784         }
2785       if (section_number == SHN_LORESERVE)
2786         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2787       t->strtab_section = section_number++;
2788       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2789     }
2790
2791   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2792   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2793
2794   elf_numsections (abfd) = section_number;
2795   elf_elfheader (abfd)->e_shnum = section_number;
2796   if (section_number > SHN_LORESERVE)
2797     elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2798
2799   /* Set up the list of section header pointers, in agreement with the
2800      indices.  */
2801   amt = section_number * sizeof (Elf_Internal_Shdr *);
2802   i_shdrp = bfd_zalloc (abfd, amt);
2803   if (i_shdrp == NULL)
2804     return FALSE;
2805
2806   amt = sizeof (Elf_Internal_Shdr);
2807   i_shdrp[0] = bfd_zalloc (abfd, amt);
2808   if (i_shdrp[0] == NULL)
2809     {
2810       bfd_release (abfd, i_shdrp);
2811       return FALSE;
2812     }
2813
2814   elf_elfsections (abfd) = i_shdrp;
2815
2816   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2817   if (bfd_get_symcount (abfd) > 0)
2818     {
2819       i_shdrp[t->symtab_section] = &t->symtab_hdr;
2820       if (elf_numsections (abfd) > SHN_LORESERVE)
2821         {
2822           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2823           t->symtab_shndx_hdr.sh_link = t->symtab_section;
2824         }
2825       i_shdrp[t->strtab_section] = &t->strtab_hdr;
2826       t->symtab_hdr.sh_link = t->strtab_section;
2827     }
2828
2829   for (sec = abfd->sections; sec; sec = sec->next)
2830     {
2831       struct bfd_elf_section_data *d = elf_section_data (sec);
2832       asection *s;
2833       const char *name;
2834
2835       i_shdrp[d->this_idx] = &d->this_hdr;
2836       if (d->rel_idx != 0)
2837         i_shdrp[d->rel_idx] = &d->rel_hdr;
2838       if (d->rel_idx2 != 0)
2839         i_shdrp[d->rel_idx2] = d->rel_hdr2;
2840
2841       /* Fill in the sh_link and sh_info fields while we're at it.  */
2842
2843       /* sh_link of a reloc section is the section index of the symbol
2844          table.  sh_info is the section index of the section to which
2845          the relocation entries apply.  */
2846       if (d->rel_idx != 0)
2847         {
2848           d->rel_hdr.sh_link = t->symtab_section;
2849           d->rel_hdr.sh_info = d->this_idx;
2850         }
2851       if (d->rel_idx2 != 0)
2852         {
2853           d->rel_hdr2->sh_link = t->symtab_section;
2854           d->rel_hdr2->sh_info = d->this_idx;
2855         }
2856
2857       /* We need to set up sh_link for SHF_LINK_ORDER.  */
2858       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
2859         {
2860           s = elf_linked_to_section (sec);
2861           if (s)
2862             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2863           else
2864             {
2865               struct bfd_link_order *p;
2866
2867               /* Find out what the corresponding section in output
2868                  is.  */
2869               for (p = sec->link_order_head; p != NULL; p = p->next)
2870                 {
2871                   s = p->u.indirect.section;
2872                   if (p->type == bfd_indirect_link_order
2873                       && (bfd_get_flavour (s->owner)
2874                           == bfd_target_elf_flavour))
2875                     {
2876                       Elf_Internal_Shdr ** const elf_shdrp
2877                         = elf_elfsections (s->owner);
2878                       int elfsec
2879                         = _bfd_elf_section_from_bfd_section (s->owner, s);
2880                       elfsec = elf_shdrp[elfsec]->sh_link;
2881                       /* PR 290:
2882                          The Intel C compiler generates SHT_IA_64_UNWIND with
2883                          SHF_LINK_ORDER.  But it doesn't set theh sh_link or
2884                          sh_info fields.  Hence we could get the situation
2885                          where elfsec is 0.  */
2886                       if (elfsec == 0)
2887                         {
2888                           const struct elf_backend_data *bed
2889                             = get_elf_backend_data (abfd);
2890                           if (bed->link_order_error_handler)
2891                             bed->link_order_error_handler
2892                               (_("%B: warning: sh_link not set for section `%S'"),
2893                                abfd, s);
2894                         }
2895                       else
2896                         {
2897                           s = elf_shdrp[elfsec]->bfd_section->output_section;
2898                           BFD_ASSERT (s != NULL);
2899                           d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2900                         }
2901                       break;
2902                     }
2903                 }
2904             }
2905         }
2906
2907       switch (d->this_hdr.sh_type)
2908         {
2909         case SHT_REL:
2910         case SHT_RELA:
2911           /* A reloc section which we are treating as a normal BFD
2912              section.  sh_link is the section index of the symbol
2913              table.  sh_info is the section index of the section to
2914              which the relocation entries apply.  We assume that an
2915              allocated reloc section uses the dynamic symbol table.
2916              FIXME: How can we be sure?  */
2917           s = bfd_get_section_by_name (abfd, ".dynsym");
2918           if (s != NULL)
2919             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2920
2921           /* We look up the section the relocs apply to by name.  */
2922           name = sec->name;
2923           if (d->this_hdr.sh_type == SHT_REL)
2924             name += 4;
2925           else
2926             name += 5;
2927           s = bfd_get_section_by_name (abfd, name);
2928           if (s != NULL)
2929             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2930           break;
2931
2932         case SHT_STRTAB:
2933           /* We assume that a section named .stab*str is a stabs
2934              string section.  We look for a section with the same name
2935              but without the trailing ``str'', and set its sh_link
2936              field to point to this section.  */
2937           if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
2938               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2939             {
2940               size_t len;
2941               char *alc;
2942
2943               len = strlen (sec->name);
2944               alc = bfd_malloc (len - 2);
2945               if (alc == NULL)
2946                 return FALSE;
2947               memcpy (alc, sec->name, len - 3);
2948               alc[len - 3] = '\0';
2949               s = bfd_get_section_by_name (abfd, alc);
2950               free (alc);
2951               if (s != NULL)
2952                 {
2953                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2954
2955                   /* This is a .stab section.  */
2956                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
2957                     elf_section_data (s)->this_hdr.sh_entsize
2958                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
2959                 }
2960             }
2961           break;
2962
2963         case SHT_DYNAMIC:
2964         case SHT_DYNSYM:
2965         case SHT_GNU_verneed:
2966         case SHT_GNU_verdef:
2967           /* sh_link is the section header index of the string table
2968              used for the dynamic entries, or the symbol table, or the
2969              version strings.  */
2970           s = bfd_get_section_by_name (abfd, ".dynstr");
2971           if (s != NULL)
2972             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2973           break;
2974
2975         case SHT_GNU_LIBLIST:
2976           /* sh_link is the section header index of the prelink library
2977              list
2978              used for the dynamic entries, or the symbol table, or the
2979              version strings.  */
2980           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
2981                                              ? ".dynstr" : ".gnu.libstr");
2982           if (s != NULL)
2983             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2984           break;
2985
2986         case SHT_HASH:
2987         case SHT_GNU_versym:
2988           /* sh_link is the section header index of the symbol table
2989              this hash table or version table is for.  */
2990           s = bfd_get_section_by_name (abfd, ".dynsym");
2991           if (s != NULL)
2992             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2993           break;
2994
2995         case SHT_GROUP:
2996           d->this_hdr.sh_link = t->symtab_section;
2997         }
2998     }
2999
3000   for (secn = 1; secn < section_number; ++secn)
3001     if (i_shdrp[secn] == NULL)
3002       i_shdrp[secn] = i_shdrp[0];
3003     else
3004       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3005                                                        i_shdrp[secn]->sh_name);
3006   return TRUE;
3007 }
3008
3009 /* Map symbol from it's internal number to the external number, moving
3010    all local symbols to be at the head of the list.  */
3011
3012 static int
3013 sym_is_global (bfd *abfd, asymbol *sym)
3014 {
3015   /* If the backend has a special mapping, use it.  */
3016   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3017   if (bed->elf_backend_sym_is_global)
3018     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3019
3020   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3021           || bfd_is_und_section (bfd_get_section (sym))
3022           || bfd_is_com_section (bfd_get_section (sym)));
3023 }
3024
3025 static bfd_boolean
3026 elf_map_symbols (bfd *abfd)
3027 {
3028   unsigned int symcount = bfd_get_symcount (abfd);
3029   asymbol **syms = bfd_get_outsymbols (abfd);
3030   asymbol **sect_syms;
3031   unsigned int num_locals = 0;
3032   unsigned int num_globals = 0;
3033   unsigned int num_locals2 = 0;
3034   unsigned int num_globals2 = 0;
3035   int max_index = 0;
3036   unsigned int idx;
3037   asection *asect;
3038   asymbol **new_syms;
3039   bfd_size_type amt;
3040
3041 #ifdef DEBUG
3042   fprintf (stderr, "elf_map_symbols\n");
3043   fflush (stderr);
3044 #endif
3045
3046   for (asect = abfd->sections; asect; asect = asect->next)
3047     {
3048       if (max_index < asect->index)
3049         max_index = asect->index;
3050     }
3051
3052   max_index++;
3053   amt = max_index * sizeof (asymbol *);
3054   sect_syms = bfd_zalloc (abfd, amt);
3055   if (sect_syms == NULL)
3056     return FALSE;
3057   elf_section_syms (abfd) = sect_syms;
3058   elf_num_section_syms (abfd) = max_index;
3059
3060   /* Init sect_syms entries for any section symbols we have already
3061      decided to output.  */
3062   for (idx = 0; idx < symcount; idx++)
3063     {
3064       asymbol *sym = syms[idx];
3065
3066       if ((sym->flags & BSF_SECTION_SYM) != 0
3067           && sym->value == 0)
3068         {
3069           asection *sec;
3070
3071           sec = sym->section;
3072
3073           if (sec->owner != NULL)
3074             {
3075               if (sec->owner != abfd)
3076                 {
3077                   if (sec->output_offset != 0)
3078                     continue;
3079
3080                   sec = sec->output_section;
3081
3082                   /* Empty sections in the input files may have had a
3083                      section symbol created for them.  (See the comment
3084                      near the end of _bfd_generic_link_output_symbols in
3085                      linker.c).  If the linker script discards such
3086                      sections then we will reach this point.  Since we know
3087                      that we cannot avoid this case, we detect it and skip
3088                      the abort and the assignment to the sect_syms array.
3089                      To reproduce this particular case try running the
3090                      linker testsuite test ld-scripts/weak.exp for an ELF
3091                      port that uses the generic linker.  */
3092                   if (sec->owner == NULL)
3093                     continue;
3094
3095                   BFD_ASSERT (sec->owner == abfd);
3096                 }
3097               sect_syms[sec->index] = syms[idx];
3098             }
3099         }
3100     }
3101
3102   /* Classify all of the symbols.  */
3103   for (idx = 0; idx < symcount; idx++)
3104     {
3105       if (!sym_is_global (abfd, syms[idx]))
3106         num_locals++;
3107       else
3108         num_globals++;
3109     }
3110
3111   /* We will be adding a section symbol for each BFD section.  Most normal
3112      sections will already have a section symbol in outsymbols, but
3113      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3114      at least in that case.  */
3115   for (asect = abfd->sections; asect; asect = asect->next)
3116     {
3117       if (sect_syms[asect->index] == NULL)
3118         {
3119           if (!sym_is_global (abfd, asect->symbol))
3120             num_locals++;
3121           else
3122             num_globals++;
3123         }
3124     }
3125
3126   /* Now sort the symbols so the local symbols are first.  */
3127   amt = (num_locals + num_globals) * sizeof (asymbol *);
3128   new_syms = bfd_alloc (abfd, amt);
3129
3130   if (new_syms == NULL)
3131     return FALSE;
3132
3133   for (idx = 0; idx < symcount; idx++)
3134     {
3135       asymbol *sym = syms[idx];
3136       unsigned int i;
3137
3138       if (!sym_is_global (abfd, sym))
3139         i = num_locals2++;
3140       else
3141         i = num_locals + num_globals2++;
3142       new_syms[i] = sym;
3143       sym->udata.i = i + 1;
3144     }
3145   for (asect = abfd->sections; asect; asect = asect->next)
3146     {
3147       if (sect_syms[asect->index] == NULL)
3148         {
3149           asymbol *sym = asect->symbol;
3150           unsigned int i;
3151
3152           sect_syms[asect->index] = sym;
3153           if (!sym_is_global (abfd, sym))
3154             i = num_locals2++;
3155           else
3156             i = num_locals + num_globals2++;
3157           new_syms[i] = sym;
3158           sym->udata.i = i + 1;
3159         }
3160     }
3161
3162   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3163
3164   elf_num_locals (abfd) = num_locals;
3165   elf_num_globals (abfd) = num_globals;
3166   return TRUE;
3167 }
3168
3169 /* Align to the maximum file alignment that could be required for any
3170    ELF data structure.  */
3171
3172 static inline file_ptr
3173 align_file_position (file_ptr off, int align)
3174 {
3175   return (off + align - 1) & ~(align - 1);
3176 }
3177
3178 /* Assign a file position to a section, optionally aligning to the
3179    required section alignment.  */
3180
3181 file_ptr
3182 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3183                                            file_ptr offset,
3184                                            bfd_boolean align)
3185 {
3186   if (align)
3187     {
3188       unsigned int al;
3189
3190       al = i_shdrp->sh_addralign;
3191       if (al > 1)
3192         offset = BFD_ALIGN (offset, al);
3193     }
3194   i_shdrp->sh_offset = offset;
3195   if (i_shdrp->bfd_section != NULL)
3196     i_shdrp->bfd_section->filepos = offset;
3197   if (i_shdrp->sh_type != SHT_NOBITS)
3198     offset += i_shdrp->sh_size;
3199   return offset;
3200 }
3201
3202 /* Compute the file positions we are going to put the sections at, and
3203    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3204    is not NULL, this is being called by the ELF backend linker.  */
3205
3206 bfd_boolean
3207 _bfd_elf_compute_section_file_positions (bfd *abfd,
3208                                          struct bfd_link_info *link_info)
3209 {
3210   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3211   bfd_boolean failed;
3212   struct bfd_strtab_hash *strtab;
3213   Elf_Internal_Shdr *shstrtab_hdr;
3214
3215   if (abfd->output_has_begun)
3216     return TRUE;
3217
3218   /* Do any elf backend specific processing first.  */
3219   if (bed->elf_backend_begin_write_processing)
3220     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3221
3222   if (! prep_headers (abfd))
3223     return FALSE;
3224
3225   /* Post process the headers if necessary.  */
3226   if (bed->elf_backend_post_process_headers)
3227     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3228
3229   failed = FALSE;
3230   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3231   if (failed)
3232     return FALSE;
3233
3234   if (!assign_section_numbers (abfd))
3235     return FALSE;
3236
3237   /* The backend linker builds symbol table information itself.  */
3238   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3239     {
3240       /* Non-zero if doing a relocatable link.  */
3241       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3242
3243       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3244         return FALSE;
3245     }
3246
3247   if (link_info == NULL)
3248     {
3249       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3250       if (failed)
3251         return FALSE;
3252     }
3253
3254   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3255   /* sh_name was set in prep_headers.  */
3256   shstrtab_hdr->sh_type = SHT_STRTAB;
3257   shstrtab_hdr->sh_flags = 0;
3258   shstrtab_hdr->sh_addr = 0;
3259   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3260   shstrtab_hdr->sh_entsize = 0;
3261   shstrtab_hdr->sh_link = 0;
3262   shstrtab_hdr->sh_info = 0;
3263   /* sh_offset is set in assign_file_positions_except_relocs.  */
3264   shstrtab_hdr->sh_addralign = 1;
3265
3266   if (!assign_file_positions_except_relocs (abfd, link_info))
3267     return FALSE;
3268
3269   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3270     {
3271       file_ptr off;
3272       Elf_Internal_Shdr *hdr;
3273
3274       off = elf_tdata (abfd)->next_file_pos;
3275
3276       hdr = &elf_tdata (abfd)->symtab_hdr;
3277       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3278
3279       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3280       if (hdr->sh_size != 0)
3281         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3282
3283       hdr = &elf_tdata (abfd)->strtab_hdr;
3284       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3285
3286       elf_tdata (abfd)->next_file_pos = off;
3287
3288       /* Now that we know where the .strtab section goes, write it
3289          out.  */
3290       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3291           || ! _bfd_stringtab_emit (abfd, strtab))
3292         return FALSE;
3293       _bfd_stringtab_free (strtab);
3294     }
3295
3296   abfd->output_has_begun = TRUE;
3297
3298   return TRUE;
3299 }
3300
3301 /* Create a mapping from a set of sections to a program segment.  */
3302
3303 static struct elf_segment_map *
3304 make_mapping (bfd *abfd,
3305               asection **sections,
3306               unsigned int from,
3307               unsigned int to,
3308               bfd_boolean phdr)
3309 {
3310   struct elf_segment_map *m;
3311   unsigned int i;
3312   asection **hdrpp;
3313   bfd_size_type amt;
3314
3315   amt = sizeof (struct elf_segment_map);
3316   amt += (to - from - 1) * sizeof (asection *);
3317   m = bfd_zalloc (abfd, amt);
3318   if (m == NULL)
3319     return NULL;
3320   m->next = NULL;
3321   m->p_type = PT_LOAD;
3322   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3323     m->sections[i - from] = *hdrpp;
3324   m->count = to - from;
3325
3326   if (from == 0 && phdr)
3327     {
3328       /* Include the headers in the first PT_LOAD segment.  */
3329       m->includes_filehdr = 1;
3330       m->includes_phdrs = 1;
3331     }
3332
3333   return m;
3334 }
3335
3336 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
3337    on failure.  */
3338
3339 struct elf_segment_map *
3340 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3341 {
3342   struct elf_segment_map *m;
3343
3344   m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3345   if (m == NULL)
3346     return NULL;
3347   m->next = NULL;
3348   m->p_type = PT_DYNAMIC;
3349   m->count = 1;
3350   m->sections[0] = dynsec;
3351
3352   return m;
3353 }
3354
3355 /* Set up a mapping from BFD sections to program segments.  */
3356
3357 static bfd_boolean
3358 map_sections_to_segments (bfd *abfd)
3359 {
3360   asection **sections = NULL;
3361   asection *s;
3362   unsigned int i;
3363   unsigned int count;
3364   struct elf_segment_map *mfirst;
3365   struct elf_segment_map **pm;
3366   struct elf_segment_map *m;
3367   asection *last_hdr;
3368   bfd_vma last_size;
3369   unsigned int phdr_index;
3370   bfd_vma maxpagesize;
3371   asection **hdrpp;
3372   bfd_boolean phdr_in_segment = TRUE;
3373   bfd_boolean writable;
3374   int tls_count = 0;
3375   asection *first_tls = NULL;
3376   asection *dynsec, *eh_frame_hdr;
3377   bfd_size_type amt;
3378
3379   if (elf_tdata (abfd)->segment_map != NULL)
3380     return TRUE;
3381
3382   if (bfd_count_sections (abfd) == 0)
3383     return TRUE;
3384
3385   /* Select the allocated sections, and sort them.  */
3386
3387   amt = bfd_count_sections (abfd) * sizeof (asection *);
3388   sections = bfd_malloc (amt);
3389   if (sections == NULL)
3390     goto error_return;
3391
3392   i = 0;
3393   for (s = abfd->sections; s != NULL; s = s->next)
3394     {
3395       if ((s->flags & SEC_ALLOC) != 0)
3396         {
3397           sections[i] = s;
3398           ++i;
3399         }
3400     }
3401   BFD_ASSERT (i <= bfd_count_sections (abfd));
3402   count = i;
3403
3404   qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3405
3406   /* Build the mapping.  */
3407
3408   mfirst = NULL;
3409   pm = &mfirst;
3410
3411   /* If we have a .interp section, then create a PT_PHDR segment for
3412      the program headers and a PT_INTERP segment for the .interp
3413      section.  */
3414   s = bfd_get_section_by_name (abfd, ".interp");
3415   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3416     {
3417       amt = sizeof (struct elf_segment_map);
3418       m = bfd_zalloc (abfd, amt);
3419       if (m == NULL)
3420         goto error_return;
3421       m->next = NULL;
3422       m->p_type = PT_PHDR;
3423       /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3424       m->p_flags = PF_R | PF_X;
3425       m->p_flags_valid = 1;
3426       m->includes_phdrs = 1;
3427
3428       *pm = m;
3429       pm = &m->next;
3430
3431       amt = sizeof (struct elf_segment_map);
3432       m = bfd_zalloc (abfd, amt);
3433       if (m == NULL)
3434         goto error_return;
3435       m->next = NULL;
3436       m->p_type = PT_INTERP;
3437       m->count = 1;
3438       m->sections[0] = s;
3439
3440       *pm = m;
3441       pm = &m->next;
3442     }
3443
3444   /* Look through the sections.  We put sections in the same program
3445      segment when the start of the second section can be placed within
3446      a few bytes of the end of the first section.  */
3447   last_hdr = NULL;
3448   last_size = 0;
3449   phdr_index = 0;
3450   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3451   writable = FALSE;
3452   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3453   if (dynsec != NULL
3454       && (dynsec->flags & SEC_LOAD) == 0)
3455     dynsec = NULL;
3456
3457   /* Deal with -Ttext or something similar such that the first section
3458      is not adjacent to the program headers.  This is an
3459      approximation, since at this point we don't know exactly how many
3460      program headers we will need.  */
3461   if (count > 0)
3462     {
3463       bfd_size_type phdr_size;
3464
3465       phdr_size = elf_tdata (abfd)->program_header_size;
3466       if (phdr_size == 0)
3467         phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3468       if ((abfd->flags & D_PAGED) == 0
3469           || sections[0]->lma < phdr_size
3470           || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3471         phdr_in_segment = FALSE;
3472     }
3473
3474   for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3475     {
3476       asection *hdr;
3477       bfd_boolean new_segment;
3478
3479       hdr = *hdrpp;
3480
3481       /* See if this section and the last one will fit in the same
3482          segment.  */
3483
3484       if (last_hdr == NULL)
3485         {
3486           /* If we don't have a segment yet, then we don't need a new
3487              one (we build the last one after this loop).  */
3488           new_segment = FALSE;
3489         }
3490       else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3491         {
3492           /* If this section has a different relation between the
3493              virtual address and the load address, then we need a new
3494              segment.  */
3495           new_segment = TRUE;
3496         }
3497       else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3498                < BFD_ALIGN (hdr->lma, maxpagesize))
3499         {
3500           /* If putting this section in this segment would force us to
3501              skip a page in the segment, then we need a new segment.  */
3502           new_segment = TRUE;
3503         }
3504       else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3505                && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3506         {
3507           /* We don't want to put a loadable section after a
3508              nonloadable section in the same segment.
3509              Consider .tbss sections as loadable for this purpose.  */
3510           new_segment = TRUE;
3511         }
3512       else if ((abfd->flags & D_PAGED) == 0)
3513         {
3514           /* If the file is not demand paged, which means that we
3515              don't require the sections to be correctly aligned in the
3516              file, then there is no other reason for a new segment.  */
3517           new_segment = FALSE;
3518         }
3519       else if (! writable
3520                && (hdr->flags & SEC_READONLY) == 0
3521                && (((last_hdr->lma + last_size - 1)
3522                     & ~(maxpagesize - 1))
3523                    != (hdr->lma & ~(maxpagesize - 1))))
3524         {
3525           /* We don't want to put a writable section in a read only
3526              segment, unless they are on the same page in memory
3527              anyhow.  We already know that the last section does not
3528              bring us past the current section on the page, so the
3529              only case in which the new section is not on the same
3530              page as the previous section is when the previous section
3531              ends precisely on a page boundary.  */
3532           new_segment = TRUE;
3533         }
3534       else
3535         {
3536           /* Otherwise, we can use the same segment.  */
3537           new_segment = FALSE;
3538         }
3539
3540       if (! new_segment)
3541         {
3542           if ((hdr->flags & SEC_READONLY) == 0)
3543             writable = TRUE;
3544           last_hdr = hdr;
3545           /* .tbss sections effectively have zero size.  */
3546           if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3547             last_size = hdr->size;
3548           else
3549             last_size = 0;
3550           continue;
3551         }
3552
3553       /* We need a new program segment.  We must create a new program
3554          header holding all the sections from phdr_index until hdr.  */
3555
3556       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3557       if (m == NULL)
3558         goto error_return;
3559
3560       *pm = m;
3561       pm = &m->next;
3562
3563       if ((hdr->flags & SEC_READONLY) == 0)
3564         writable = TRUE;
3565       else
3566         writable = FALSE;
3567
3568       last_hdr = hdr;
3569       /* .tbss sections effectively have zero size.  */
3570       if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3571         last_size = hdr->size;
3572       else
3573         last_size = 0;
3574       phdr_index = i;
3575       phdr_in_segment = FALSE;
3576     }
3577
3578   /* Create a final PT_LOAD program segment.  */
3579   if (last_hdr != NULL)
3580     {
3581       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3582       if (m == NULL)
3583         goto error_return;
3584
3585       *pm = m;
3586       pm = &m->next;
3587     }
3588
3589   /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
3590   if (dynsec != NULL)
3591     {
3592       m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3593       if (m == NULL)
3594         goto error_return;
3595       *pm = m;
3596       pm = &m->next;
3597     }
3598
3599   /* For each loadable .note section, add a PT_NOTE segment.  We don't
3600      use bfd_get_section_by_name, because if we link together
3601      nonloadable .note sections and loadable .note sections, we will
3602      generate two .note sections in the output file.  FIXME: Using
3603      names for section types is bogus anyhow.  */
3604   for (s = abfd->sections; s != NULL; s = s->next)
3605     {
3606       if ((s->flags & SEC_LOAD) != 0
3607           && strncmp (s->name, ".note", 5) == 0)
3608         {
3609           amt = sizeof (struct elf_segment_map);
3610           m = bfd_zalloc (abfd, amt);
3611           if (m == NULL)
3612             goto error_return;
3613           m->next = NULL;
3614           m->p_type = PT_NOTE;
3615           m->count = 1;
3616           m->sections[0] = s;
3617
3618           *pm = m;
3619           pm = &m->next;
3620         }
3621       if (s->flags & SEC_THREAD_LOCAL)
3622         {
3623           if (! tls_count)
3624             first_tls = s;
3625           tls_count++;
3626         }
3627     }
3628
3629   /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
3630   if (tls_count > 0)
3631     {
3632       int i;
3633
3634       amt = sizeof (struct elf_segment_map);
3635       amt += (tls_count - 1) * sizeof (asection *);
3636       m = bfd_zalloc (abfd, amt);
3637       if (m == NULL)
3638         goto error_return;
3639       m->next = NULL;
3640       m->p_type = PT_TLS;
3641       m->count = tls_count;
3642       /* Mandated PF_R.  */
3643       m->p_flags = PF_R;
3644       m->p_flags_valid = 1;
3645       for (i = 0; i < tls_count; ++i)
3646         {
3647           BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3648           m->sections[i] = first_tls;
3649           first_tls = first_tls->next;
3650         }
3651
3652       *pm = m;
3653       pm = &m->next;
3654     }
3655
3656   /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3657      segment.  */
3658   eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3659   if (eh_frame_hdr != NULL
3660       && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3661     {
3662       amt = sizeof (struct elf_segment_map);
3663       m = bfd_zalloc (abfd, amt);
3664       if (m == NULL)
3665         goto error_return;
3666       m->next = NULL;
3667       m->p_type = PT_GNU_EH_FRAME;
3668       m->count = 1;
3669       m->sections[0] = eh_frame_hdr->output_section;
3670
3671       *pm = m;
3672       pm = &m->next;
3673     }
3674
3675   if (elf_tdata (abfd)->stack_flags)
3676     {
3677       amt = sizeof (struct elf_segment_map);
3678       m = bfd_zalloc (abfd, amt);
3679       if (m == NULL)
3680         goto error_return;
3681       m->next = NULL;
3682       m->p_type = PT_GNU_STACK;
3683       m->p_flags = elf_tdata (abfd)->stack_flags;
3684       m->p_flags_valid = 1;
3685
3686       *pm = m;
3687       pm = &m->next;
3688     }
3689
3690   if (elf_tdata (abfd)->relro)
3691     {
3692       amt = sizeof (struct elf_segment_map);
3693       m = bfd_zalloc (abfd, amt);
3694       if (m == NULL)
3695         goto error_return;
3696       m->next = NULL;
3697       m->p_type = PT_GNU_RELRO;
3698       m->p_flags = PF_R;
3699       m->p_flags_valid = 1;
3700
3701       *pm = m;
3702       pm = &m->next;
3703     }
3704
3705   free (sections);
3706   sections = NULL;
3707
3708   elf_tdata (abfd)->segment_map = mfirst;
3709   return TRUE;
3710
3711  error_return:
3712   if (sections != NULL)
3713     free (sections);
3714   return FALSE;
3715 }
3716
3717 /* Sort sections by address.  */
3718
3719 static int
3720 elf_sort_sections (const void *arg1, const void *arg2)
3721 {
3722   const asection *sec1 = *(const asection **) arg1;
3723   const asection *sec2 = *(const asection **) arg2;
3724   bfd_size_type size1, size2;
3725
3726   /* Sort by LMA first, since this is the address used to
3727      place the section into a segment.  */
3728   if (sec1->lma < sec2->lma)
3729     return -1;
3730   else if (sec1->lma > sec2->lma)
3731     return 1;
3732
3733   /* Then sort by VMA.  Normally the LMA and the VMA will be
3734      the same, and this will do nothing.  */
3735   if (sec1->vma < sec2->vma)
3736     return -1;
3737   else if (sec1->vma > sec2->vma)
3738     return 1;
3739
3740   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
3741
3742 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3743
3744   if (TOEND (sec1))
3745     {
3746       if (TOEND (sec2))
3747         {
3748           /* If the indicies are the same, do not return 0
3749              here, but continue to try the next comparison.  */
3750           if (sec1->target_index - sec2->target_index != 0)
3751             return sec1->target_index - sec2->target_index;
3752         }
3753       else
3754         return 1;
3755     }
3756   else if (TOEND (sec2))
3757     return -1;
3758
3759 #undef TOEND
3760
3761   /* Sort by size, to put zero sized sections
3762      before others at the same address.  */
3763
3764   size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
3765   size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
3766
3767   if (size1 < size2)
3768     return -1;
3769   if (size1 > size2)
3770     return 1;
3771
3772   return sec1->target_index - sec2->target_index;
3773 }
3774
3775 /* Ian Lance Taylor writes:
3776
3777    We shouldn't be using % with a negative signed number.  That's just
3778    not good.  We have to make sure either that the number is not
3779    negative, or that the number has an unsigned type.  When the types
3780    are all the same size they wind up as unsigned.  When file_ptr is a
3781    larger signed type, the arithmetic winds up as signed long long,
3782    which is wrong.
3783
3784    What we're trying to say here is something like ``increase OFF by
3785    the least amount that will cause it to be equal to the VMA modulo
3786    the page size.''  */
3787 /* In other words, something like:
3788
3789    vma_offset = m->sections[0]->vma % bed->maxpagesize;
3790    off_offset = off % bed->maxpagesize;
3791    if (vma_offset < off_offset)
3792      adjustment = vma_offset + bed->maxpagesize - off_offset;
3793    else
3794      adjustment = vma_offset - off_offset;
3795
3796    which can can be collapsed into the expression below.  */
3797
3798 static file_ptr
3799 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
3800 {
3801   return ((vma - off) % maxpagesize);
3802 }
3803
3804 /* Assign file positions to the sections based on the mapping from
3805    sections to segments.  This function also sets up some fields in
3806    the file header, and writes out the program headers.  */
3807
3808 static bfd_boolean
3809 assign_file_positions_for_segments (bfd *abfd, struct bfd_link_info *link_info)
3810 {
3811   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3812   unsigned int count;
3813   struct elf_segment_map *m;
3814   unsigned int alloc;
3815   Elf_Internal_Phdr *phdrs;
3816   file_ptr off, voff;
3817   bfd_vma filehdr_vaddr, filehdr_paddr;
3818   bfd_vma phdrs_vaddr, phdrs_paddr;
3819   Elf_Internal_Phdr *p;
3820   bfd_size_type amt;
3821
3822   if (elf_tdata (abfd)->segment_map == NULL)
3823     {
3824       if (! map_sections_to_segments (abfd))
3825         return FALSE;
3826     }
3827   else
3828     {
3829       /* The placement algorithm assumes that non allocated sections are
3830          not in PT_LOAD segments.  We ensure this here by removing such
3831          sections from the segment map.  */
3832       for (m = elf_tdata (abfd)->segment_map;
3833            m != NULL;
3834            m = m->next)
3835         {
3836           unsigned int new_count;
3837           unsigned int i;
3838
3839           if (m->p_type != PT_LOAD)
3840             continue;
3841
3842           new_count = 0;
3843           for (i = 0; i < m->count; i ++)
3844             {
3845               if ((m->sections[i]->flags & SEC_ALLOC) != 0)
3846                 {
3847                   if (i != new_count)
3848                     m->sections[new_count] = m->sections[i];
3849
3850                   new_count ++;
3851                 }
3852             }
3853
3854           if (new_count != m->count)
3855             m->count = new_count;
3856         }
3857     }
3858
3859   if (bed->elf_backend_modify_segment_map)
3860     {
3861       if (! (*bed->elf_backend_modify_segment_map) (abfd, link_info))
3862         return FALSE;
3863     }
3864
3865   count = 0;
3866   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3867     ++count;
3868
3869   elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3870   elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3871   elf_elfheader (abfd)->e_phnum = count;
3872
3873   if (count == 0)
3874     {
3875       elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
3876       return TRUE;
3877     }
3878
3879   /* If we already counted the number of program segments, make sure
3880      that we allocated enough space.  This happens when SIZEOF_HEADERS
3881      is used in a linker script.  */
3882   alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3883   if (alloc != 0 && count > alloc)
3884     {
3885       ((*_bfd_error_handler)
3886        (_("%B: Not enough room for program headers (allocated %u, need %u)"),
3887         abfd, alloc, count));
3888       bfd_set_error (bfd_error_bad_value);
3889       return FALSE;
3890     }
3891
3892   if (alloc == 0)
3893     alloc = count;
3894
3895   amt = alloc * sizeof (Elf_Internal_Phdr);
3896   phdrs = bfd_alloc (abfd, amt);
3897   if (phdrs == NULL)
3898     return FALSE;
3899
3900   off = bed->s->sizeof_ehdr;
3901   off += alloc * bed->s->sizeof_phdr;
3902
3903   filehdr_vaddr = 0;
3904   filehdr_paddr = 0;
3905   phdrs_vaddr = 0;
3906   phdrs_paddr = 0;
3907
3908   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3909        m != NULL;
3910        m = m->next, p++)
3911     {
3912       unsigned int i;
3913       asection **secpp;
3914
3915       /* If elf_segment_map is not from map_sections_to_segments, the
3916          sections may not be correctly ordered.  NOTE: sorting should
3917          not be done to the PT_NOTE section of a corefile, which may
3918          contain several pseudo-sections artificially created by bfd.
3919          Sorting these pseudo-sections breaks things badly.  */
3920       if (m->count > 1
3921           && !(elf_elfheader (abfd)->e_type == ET_CORE
3922                && m->p_type == PT_NOTE))
3923         qsort (m->sections, (size_t) m->count, sizeof (asection *),
3924                elf_sort_sections);
3925
3926       /* An ELF segment (described by Elf_Internal_Phdr) may contain a
3927          number of sections with contents contributing to both p_filesz
3928          and p_memsz, followed by a number of sections with no contents
3929          that just contribute to p_memsz.  In this loop, OFF tracks next
3930          available file offset for PT_LOAD and PT_NOTE segments.  VOFF is
3931          an adjustment we use for segments that have no file contents
3932          but need zero filled memory allocation.  */
3933       voff = 0;
3934       p->p_type = m->p_type;
3935       p->p_flags = m->p_flags;
3936
3937       if (p->p_type == PT_LOAD
3938           && m->count > 0)
3939         {
3940           bfd_size_type align;
3941           bfd_vma adjust;
3942
3943           if ((abfd->flags & D_PAGED) != 0)
3944             align = bed->maxpagesize;
3945           else
3946             {
3947               unsigned int align_power = 0;
3948               for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3949                 {
3950                   unsigned int secalign;
3951
3952                   secalign = bfd_get_section_alignment (abfd, *secpp);
3953                   if (secalign > align_power)
3954                     align_power = secalign;
3955                 }
3956               align = (bfd_size_type) 1 << align_power;
3957             }
3958
3959           adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
3960           off += adjust;
3961           if (adjust != 0
3962               && !m->includes_filehdr
3963               && !m->includes_phdrs
3964               && (ufile_ptr) off >= align)
3965             {
3966               /* If the first section isn't loadable, the same holds for
3967                  any other sections.  Since the segment won't need file
3968                  space, we can make p_offset overlap some prior segment.
3969                  However, .tbss is special.  If a segment starts with
3970                  .tbss, we need to look at the next section to decide
3971                  whether the segment has any loadable sections.  */
3972               i = 0;
3973               while ((m->sections[i]->flags & SEC_LOAD) == 0)
3974                 {
3975                   if ((m->sections[i]->flags & SEC_THREAD_LOCAL) == 0
3976                       || ++i >= m->count)
3977                     {
3978                       off -= adjust;
3979                       voff = adjust - align;
3980                       break;
3981                     }
3982                 }
3983             }
3984         }
3985       /* Make sure the .dynamic section is the first section in the
3986          PT_DYNAMIC segment.  */
3987       else if (p->p_type == PT_DYNAMIC
3988                && m->count > 1
3989                && strcmp (m->sections[0]->name, ".dynamic") != 0)
3990         {
3991           _bfd_error_handler
3992             (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
3993              abfd);
3994           bfd_set_error (bfd_error_bad_value);
3995           return FALSE;
3996         }
3997
3998       if (m->count == 0)
3999         p->p_vaddr = 0;
4000       else
4001         p->p_vaddr = m->sections[0]->vma;
4002
4003       if (m->p_paddr_valid)
4004         p->p_paddr = m->p_paddr;
4005       else if (m->count == 0)
4006         p->p_paddr = 0;
4007       else
4008         p->p_paddr = m->sections[0]->lma;
4009
4010       if (p->p_type == PT_LOAD
4011           && (abfd->flags & D_PAGED) != 0)
4012         p->p_align = bed->maxpagesize;
4013       else if (m->count == 0)
4014         p->p_align = 1 << bed->s->log_file_align;
4015       else
4016         p->p_align = 0;
4017
4018       p->p_offset = 0;
4019       p->p_filesz = 0;
4020       p->p_memsz = 0;
4021
4022       if (m->includes_filehdr)
4023         {
4024           if (! m->p_flags_valid)
4025             p->p_flags |= PF_R;
4026           p->p_offset = 0;
4027           p->p_filesz = bed->s->sizeof_ehdr;
4028           p->p_memsz = bed->s->sizeof_ehdr;
4029           if (m->count > 0)
4030             {
4031               BFD_ASSERT (p->p_type == PT_LOAD);
4032
4033               if (p->p_vaddr < (bfd_vma) off)
4034                 {
4035                   (*_bfd_error_handler)
4036                     (_("%B: Not enough room for program headers, try linking with -N"),
4037                      abfd);
4038                   bfd_set_error (bfd_error_bad_value);
4039                   return FALSE;
4040                 }
4041
4042               p->p_vaddr -= off;
4043               if (! m->p_paddr_valid)
4044                 p->p_paddr -= off;
4045             }
4046           if (p->p_type == PT_LOAD)
4047             {
4048               filehdr_vaddr = p->p_vaddr;
4049               filehdr_paddr = p->p_paddr;
4050             }
4051         }
4052
4053       if (m->includes_phdrs)
4054         {
4055           if (! m->p_flags_valid)
4056             p->p_flags |= PF_R;
4057
4058           if (m->includes_filehdr)
4059             {
4060               if (p->p_type == PT_LOAD)
4061                 {
4062                   phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
4063                   phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
4064                 }
4065             }
4066           else
4067             {
4068               p->p_offset = bed->s->sizeof_ehdr;
4069
4070               if (m->count > 0)
4071                 {
4072                   BFD_ASSERT (p->p_type == PT_LOAD);
4073                   p->p_vaddr -= off - p->p_offset;
4074                   if (! m->p_paddr_valid)
4075                     p->p_paddr -= off - p->p_offset;
4076                 }
4077
4078               if (p->p_type == PT_LOAD)
4079                 {
4080                   phdrs_vaddr = p->p_vaddr;
4081                   phdrs_paddr = p->p_paddr;
4082                 }
4083               else
4084                 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4085             }
4086
4087           p->p_filesz += alloc * bed->s->sizeof_phdr;
4088           p->p_memsz += alloc * bed->s->sizeof_phdr;
4089         }
4090
4091       if (p->p_type == PT_LOAD
4092           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4093         {
4094           if (! m->includes_filehdr && ! m->includes_phdrs)
4095             p->p_offset = off + voff;
4096           else
4097             {
4098               file_ptr adjust;
4099
4100               adjust = off - (p->p_offset + p->p_filesz);
4101               p->p_filesz += adjust;
4102               p->p_memsz += adjust;
4103             }
4104         }
4105
4106       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4107         {
4108           asection *sec;
4109           flagword flags;
4110           bfd_size_type align;
4111
4112           sec = *secpp;
4113           flags = sec->flags;
4114           align = 1 << bfd_get_section_alignment (abfd, sec);
4115
4116           if (p->p_type == PT_LOAD
4117               || p->p_type == PT_TLS)
4118             {
4119               bfd_signed_vma adjust;
4120
4121               if ((flags & SEC_LOAD) != 0)
4122                 {
4123                   adjust = sec->lma - (p->p_paddr + p->p_filesz);
4124                   if (adjust < 0)
4125                     {
4126                       (*_bfd_error_handler)
4127                         (_("%B: section %A lma 0x%lx overlaps previous sections"),
4128                          abfd, sec, (unsigned long) sec->lma);
4129                       adjust = 0;
4130                     }
4131                   off += adjust;
4132                   p->p_filesz += adjust;
4133                   p->p_memsz += adjust;
4134                 }
4135               /* .tbss is special.  It doesn't contribute to p_memsz of
4136                  normal segments.  */
4137               else if ((flags & SEC_THREAD_LOCAL) == 0
4138                        || p->p_type == PT_TLS)
4139                 {
4140                   /* The section VMA must equal the file position
4141                      modulo the page size.  */
4142                   bfd_size_type page = align;
4143                   if ((abfd->flags & D_PAGED) != 0)
4144                     page = bed->maxpagesize;
4145                   adjust = vma_page_aligned_bias (sec->vma,
4146                                                   p->p_vaddr + p->p_memsz,
4147                                                   page);
4148                   p->p_memsz += adjust;
4149                 }
4150             }
4151
4152           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4153             {
4154               /* The section at i == 0 is the one that actually contains
4155                  everything.  */
4156               if (i == 0)
4157                 {
4158                   sec->filepos = off;
4159                   off += sec->size;
4160                   p->p_filesz = sec->size;
4161                   p->p_memsz = 0;
4162                   p->p_align = 1;
4163                 }
4164               else
4165                 {
4166                   /* The rest are fake sections that shouldn't be written.  */
4167                   sec->filepos = 0;
4168                   sec->size = 0;
4169                   sec->flags = 0;
4170                   continue;
4171                 }
4172             }
4173           else
4174             {
4175               if (p->p_type == PT_LOAD)
4176                 {
4177                   sec->filepos = off;
4178                   /* FIXME: The SEC_HAS_CONTENTS test here dates back to
4179                      1997, and the exact reason for it isn't clear.  One
4180                      plausible explanation is that it is to work around
4181                      a problem we have with linker scripts using data
4182                      statements in NOLOAD sections.  I don't think it
4183                      makes a great deal of sense to have such a section
4184                      assigned to a PT_LOAD segment, but apparently
4185                      people do this.  The data statement results in a
4186                      bfd_data_link_order being built, and these need
4187                      section contents to write into.  Eventually, we get
4188                      to _bfd_elf_write_object_contents which writes any
4189                      section with contents to the output.  Make room
4190                      here for the write, so that following segments are
4191                      not trashed.  */
4192                   if ((flags & SEC_LOAD) != 0
4193                       || (flags & SEC_HAS_CONTENTS) != 0)
4194                     off += sec->size;
4195                 }
4196
4197               if ((flags & SEC_LOAD) != 0)
4198                 {
4199                   p->p_filesz += sec->size;
4200                   p->p_memsz += sec->size;
4201                 }
4202               /* .tbss is special.  It doesn't contribute to p_memsz of
4203                  normal segments.  */
4204               else if ((flags & SEC_THREAD_LOCAL) == 0
4205                        || p->p_type == PT_TLS)
4206                 p->p_memsz += sec->size;
4207
4208               if (p->p_type == PT_TLS
4209                   && sec->size == 0
4210                   && (sec->flags & SEC_HAS_CONTENTS) == 0)
4211                 {
4212                   struct bfd_link_order *o;
4213                   bfd_vma tbss_size = 0;
4214
4215                   for (o = sec->link_order_head; o != NULL; o = o->next)
4216                     if (tbss_size < o->offset + o->size)
4217                       tbss_size = o->offset + o->size;
4218
4219                   p->p_memsz += tbss_size;
4220                 }
4221
4222               if (align > p->p_align
4223                   && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
4224                 p->p_align = align;
4225             }
4226
4227           if (! m->p_flags_valid)
4228             {
4229               p->p_flags |= PF_R;
4230               if ((flags & SEC_CODE) != 0)
4231                 p->p_flags |= PF_X;
4232               if ((flags & SEC_READONLY) == 0)
4233                 p->p_flags |= PF_W;
4234             }
4235         }
4236     }
4237
4238   /* Now that we have set the section file positions, we can set up
4239      the file positions for the non PT_LOAD segments.  */
4240   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4241        m != NULL;
4242        m = m->next, p++)
4243     {
4244       if (p->p_type != PT_LOAD && m->count > 0)
4245         {
4246           BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
4247           /* If the section has not yet been assigned a file position,
4248              do so now.  The ARM BPABI requires that .dynamic section
4249              not be marked SEC_ALLOC because it is not part of any
4250              PT_LOAD segment, so it will not be processed above.  */
4251           if (p->p_type == PT_DYNAMIC && m->sections[0]->filepos == 0)
4252             {
4253               unsigned int i;
4254               Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4255
4256               i = 1;
4257               while (i_shdrpp[i]->bfd_section != m->sections[0])
4258                 ++i;
4259               off = (_bfd_elf_assign_file_position_for_section
4260                      (i_shdrpp[i], off, TRUE));
4261               p->p_filesz = m->sections[0]->size;
4262             }
4263           p->p_offset = m->sections[0]->filepos;
4264         }
4265       if (m->count == 0)
4266         {
4267           if (m->includes_filehdr)
4268             {
4269               p->p_vaddr = filehdr_vaddr;
4270               if (! m->p_paddr_valid)
4271                 p->p_paddr = filehdr_paddr;
4272             }
4273           else if (m->includes_phdrs)
4274             {
4275               p->p_vaddr = phdrs_vaddr;
4276               if (! m->p_paddr_valid)
4277                 p->p_paddr = phdrs_paddr;
4278             }
4279           else if (p->p_type == PT_GNU_RELRO)
4280             {
4281               Elf_Internal_Phdr *lp;
4282
4283               for (lp = phdrs; lp < phdrs + count; ++lp)
4284                 {
4285                   if (lp->p_type == PT_LOAD
4286                       && lp->p_vaddr <= link_info->relro_end
4287                       && lp->p_vaddr >= link_info->relro_start
4288                       && lp->p_vaddr + lp->p_filesz
4289                          >= link_info->relro_end)
4290                     break;
4291                 }
4292
4293               if (lp < phdrs + count
4294                   && link_info->relro_end > lp->p_vaddr)
4295                 {
4296                   p->p_vaddr = lp->p_vaddr;
4297                   p->p_paddr = lp->p_paddr;
4298                   p->p_offset = lp->p_offset;
4299                   p->p_filesz = link_info->relro_end - lp->p_vaddr;
4300                   p->p_memsz = p->p_filesz;
4301                   p->p_align = 1;
4302                   p->p_flags = (lp->p_flags & ~PF_W);
4303                 }
4304               else
4305                 {
4306                   memset (p, 0, sizeof *p);
4307                   p->p_type = PT_NULL;
4308                 }
4309             }
4310         }
4311     }
4312
4313   /* Clear out any program headers we allocated but did not use.  */
4314   for (; count < alloc; count++, p++)
4315     {
4316       memset (p, 0, sizeof *p);
4317       p->p_type = PT_NULL;
4318     }
4319
4320   elf_tdata (abfd)->phdr = phdrs;
4321
4322   elf_tdata (abfd)->next_file_pos = off;
4323
4324   /* Write out the program headers.  */
4325   if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4326       || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
4327     return FALSE;
4328
4329   return TRUE;
4330 }
4331
4332 /* Get the size of the program header.
4333
4334    If this is called by the linker before any of the section VMA's are set, it
4335    can't calculate the correct value for a strange memory layout.  This only
4336    happens when SIZEOF_HEADERS is used in a linker script.  In this case,
4337    SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4338    data segment (exclusive of .interp and .dynamic).
4339
4340    ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4341    will be two segments.  */
4342
4343 static bfd_size_type
4344 get_program_header_size (bfd *abfd)
4345 {
4346   size_t segs;
4347   asection *s;
4348   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4349
4350   /* We can't return a different result each time we're called.  */
4351   if (elf_tdata (abfd)->program_header_size != 0)
4352     return elf_tdata (abfd)->program_header_size;
4353
4354   if (elf_tdata (abfd)->segment_map != NULL)
4355     {
4356       struct elf_segment_map *m;
4357
4358       segs = 0;
4359       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4360         ++segs;
4361       elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4362       return elf_tdata (abfd)->program_header_size;
4363     }
4364
4365   /* Assume we will need exactly two PT_LOAD segments: one for text
4366      and one for data.  */
4367   segs = 2;
4368
4369   s = bfd_get_section_by_name (abfd, ".interp");
4370   if (s != NULL && (s->flags & SEC_LOAD) != 0)
4371     {
4372       /* If we have a loadable interpreter section, we need a
4373          PT_INTERP segment.  In this case, assume we also need a
4374          PT_PHDR segment, although that may not be true for all
4375          targets.  */
4376       segs += 2;
4377     }
4378
4379   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4380     {
4381       /* We need a PT_DYNAMIC segment.  */
4382       ++segs;
4383     }
4384
4385   if (elf_tdata (abfd)->eh_frame_hdr)
4386     {
4387       /* We need a PT_GNU_EH_FRAME segment.  */
4388       ++segs;
4389     }
4390
4391   if (elf_tdata (abfd)->stack_flags)
4392     {
4393       /* We need a PT_GNU_STACK segment.  */
4394       ++segs;
4395     }
4396
4397   if (elf_tdata (abfd)->relro)
4398     {
4399       /* We need a PT_GNU_RELRO segment.  */
4400       ++segs;
4401     }
4402
4403   for (s = abfd->sections; s != NULL; s = s->next)
4404     {
4405       if ((s->flags & SEC_LOAD) != 0
4406           && strncmp (s->name, ".note", 5) == 0)
4407         {
4408           /* We need a PT_NOTE segment.  */
4409           ++segs;
4410         }
4411     }
4412
4413   for (s = abfd->sections; s != NULL; s = s->next)
4414     {
4415       if (s->flags & SEC_THREAD_LOCAL)
4416         {
4417           /* We need a PT_TLS segment.  */
4418           ++segs;
4419           break;
4420         }
4421     }
4422
4423   /* Let the backend count up any program headers it might need.  */
4424   if (bed->elf_backend_additional_program_headers)
4425     {
4426       int a;
4427
4428       a = (*bed->elf_backend_additional_program_headers) (abfd);
4429       if (a == -1)
4430         abort ();
4431       segs += a;
4432     }
4433
4434   elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4435   return elf_tdata (abfd)->program_header_size;
4436 }
4437
4438 /* Work out the file positions of all the sections.  This is called by
4439    _bfd_elf_compute_section_file_positions.  All the section sizes and
4440    VMAs must be known before this is called.
4441
4442    Reloc sections come in two flavours: Those processed specially as
4443    "side-channel" data attached to a section to which they apply, and
4444    those that bfd doesn't process as relocations.  The latter sort are
4445    stored in a normal bfd section by bfd_section_from_shdr.   We don't
4446    consider the former sort here, unless they form part of the loadable
4447    image.  Reloc sections not assigned here will be handled later by
4448    assign_file_positions_for_relocs.
4449
4450    We also don't set the positions of the .symtab and .strtab here.  */
4451
4452 static bfd_boolean
4453 assign_file_positions_except_relocs (bfd *abfd,
4454                                      struct bfd_link_info *link_info)
4455 {
4456   struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4457   Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4458   Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4459   unsigned int num_sec = elf_numsections (abfd);
4460   file_ptr off;
4461   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4462
4463   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4464       && bfd_get_format (abfd) != bfd_core)
4465     {
4466       Elf_Internal_Shdr **hdrpp;
4467       unsigned int i;
4468
4469       /* Start after the ELF header.  */
4470       off = i_ehdrp->e_ehsize;
4471
4472       /* We are not creating an executable, which means that we are
4473          not creating a program header, and that the actual order of
4474          the sections in the file is unimportant.  */
4475       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4476         {
4477           Elf_Internal_Shdr *hdr;
4478
4479           hdr = *hdrpp;
4480           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4481                && hdr->bfd_section == NULL)
4482               || i == tdata->symtab_section
4483               || i == tdata->symtab_shndx_section
4484               || i == tdata->strtab_section)
4485             {
4486               hdr->sh_offset = -1;
4487             }
4488           else
4489             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4490
4491           if (i == SHN_LORESERVE - 1)
4492             {
4493               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4494               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4495             }
4496         }
4497     }
4498   else
4499     {
4500       unsigned int i;
4501       Elf_Internal_Shdr **hdrpp;
4502
4503       /* Assign file positions for the loaded sections based on the
4504          assignment of sections to segments.  */
4505       if (! assign_file_positions_for_segments (abfd, link_info))
4506         return FALSE;
4507
4508       /* Assign file positions for the other sections.  */
4509
4510       off = elf_tdata (abfd)->next_file_pos;
4511       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4512         {
4513           Elf_Internal_Shdr *hdr;
4514
4515           hdr = *hdrpp;
4516           if (hdr->bfd_section != NULL
4517               && hdr->bfd_section->filepos != 0)
4518             hdr->sh_offset = hdr->bfd_section->filepos;
4519           else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4520             {
4521               ((*_bfd_error_handler)
4522                (_("%B: warning: allocated section `%s' not in segment"),
4523                 abfd,
4524                 (hdr->bfd_section == NULL
4525                  ? "*unknown*"
4526                  : hdr->bfd_section->name)));
4527               if ((abfd->flags & D_PAGED) != 0)
4528                 off += vma_page_aligned_bias (hdr->sh_addr, off,
4529                                               bed->maxpagesize);
4530               else
4531                 off += vma_page_aligned_bias (hdr->sh_addr, off,
4532                                               hdr->sh_addralign);
4533               off = _bfd_elf_assign_file_position_for_section (hdr, off,
4534                                                                FALSE);
4535             }
4536           else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4537                     && hdr->bfd_section == NULL)
4538                    || hdr == i_shdrpp[tdata->symtab_section]
4539                    || hdr == i_shdrpp[tdata->symtab_shndx_section]
4540                    || hdr == i_shdrpp[tdata->strtab_section])
4541             hdr->sh_offset = -1;
4542           else
4543             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4544
4545           if (i == SHN_LORESERVE - 1)
4546             {
4547               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4548               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4549             }
4550         }
4551     }
4552
4553   /* Place the section headers.  */
4554   off = align_file_position (off, 1 << bed->s->log_file_align);
4555   i_ehdrp->e_shoff = off;
4556   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4557
4558   elf_tdata (abfd)->next_file_pos = off;
4559
4560   return TRUE;
4561 }
4562
4563 static bfd_boolean
4564 prep_headers (bfd *abfd)
4565 {
4566   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
4567   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4568   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
4569   struct elf_strtab_hash *shstrtab;
4570   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4571
4572   i_ehdrp = elf_elfheader (abfd);
4573   i_shdrp = elf_elfsections (abfd);
4574
4575   shstrtab = _bfd_elf_strtab_init ();
4576   if (shstrtab == NULL)
4577     return FALSE;
4578
4579   elf_shstrtab (abfd) = shstrtab;
4580
4581   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4582   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4583   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4584   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4585
4586   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4587   i_ehdrp->e_ident[EI_DATA] =
4588     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4589   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4590
4591   if ((abfd->flags & DYNAMIC) != 0)
4592     i_ehdrp->e_type = ET_DYN;
4593   else if ((abfd->flags & EXEC_P) != 0)
4594     i_ehdrp->e_type = ET_EXEC;
4595   else if (bfd_get_format (abfd) == bfd_core)
4596     i_ehdrp->e_type = ET_CORE;
4597   else
4598     i_ehdrp->e_type = ET_REL;
4599
4600   switch (bfd_get_arch (abfd))
4601     {
4602     case bfd_arch_unknown:
4603       i_ehdrp->e_machine = EM_NONE;
4604       break;
4605
4606       /* There used to be a long list of cases here, each one setting
4607          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4608          in the corresponding bfd definition.  To avoid duplication,
4609          the switch was removed.  Machines that need special handling
4610          can generally do it in elf_backend_final_write_processing(),
4611          unless they need the information earlier than the final write.
4612          Such need can generally be supplied by replacing the tests for
4613          e_machine with the conditions used to determine it.  */
4614     default:
4615       i_ehdrp->e_machine = bed->elf_machine_code;
4616     }
4617
4618   i_ehdrp->e_version = bed->s->ev_current;
4619   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4620
4621   /* No program header, for now.  */
4622   i_ehdrp->e_phoff = 0;
4623   i_ehdrp->e_phentsize = 0;
4624   i_ehdrp->e_phnum = 0;
4625
4626   /* Each bfd section is section header entry.  */
4627   i_ehdrp->e_entry = bfd_get_start_address (abfd);
4628   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4629
4630   /* If we're building an executable, we'll need a program header table.  */
4631   if (abfd->flags & EXEC_P)
4632     {
4633       /* It all happens later.  */
4634 #if 0
4635       i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
4636
4637       /* elf_build_phdrs() returns a (NULL-terminated) array of
4638          Elf_Internal_Phdrs.  */
4639       i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
4640       i_ehdrp->e_phoff = outbase;
4641       outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
4642 #endif
4643     }
4644   else
4645     {
4646       i_ehdrp->e_phentsize = 0;
4647       i_phdrp = 0;
4648       i_ehdrp->e_phoff = 0;
4649     }
4650
4651   elf_tdata (abfd)->symtab_hdr.sh_name =
4652     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4653   elf_tdata (abfd)->strtab_hdr.sh_name =
4654     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4655   elf_tdata (abfd)->shstrtab_hdr.sh_name =
4656     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4657   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4658       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4659       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4660     return FALSE;
4661
4662   return TRUE;
4663 }
4664
4665 /* Assign file positions for all the reloc sections which are not part
4666    of the loadable file image.  */
4667
4668 void
4669 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4670 {
4671   file_ptr off;
4672   unsigned int i, num_sec;
4673   Elf_Internal_Shdr **shdrpp;
4674
4675   off = elf_tdata (abfd)->next_file_pos;
4676
4677   num_sec = elf_numsections (abfd);
4678   for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4679     {
4680       Elf_Internal_Shdr *shdrp;
4681
4682       shdrp = *shdrpp;
4683       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4684           && shdrp->sh_offset == -1)
4685         off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4686     }
4687
4688   elf_tdata (abfd)->next_file_pos = off;
4689 }
4690
4691 bfd_boolean
4692 _bfd_elf_write_object_contents (bfd *abfd)
4693 {
4694   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4695   Elf_Internal_Ehdr *i_ehdrp;
4696   Elf_Internal_Shdr **i_shdrp;
4697   bfd_boolean failed;
4698   unsigned int count, num_sec;
4699
4700   if (! abfd->output_has_begun
4701       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4702     return FALSE;
4703
4704   i_shdrp = elf_elfsections (abfd);
4705   i_ehdrp = elf_elfheader (abfd);
4706
4707   failed = FALSE;
4708   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4709   if (failed)
4710     return FALSE;
4711
4712   _bfd_elf_assign_file_positions_for_relocs (abfd);
4713
4714   /* After writing the headers, we need to write the sections too...  */
4715   num_sec = elf_numsections (abfd);
4716   for (count = 1; count < num_sec; count++)
4717     {
4718       if (bed->elf_backend_section_processing)
4719         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4720       if (i_shdrp[count]->contents)
4721         {
4722           bfd_size_type amt = i_shdrp[count]->sh_size;
4723
4724           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4725               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4726             return FALSE;
4727         }
4728       if (count == SHN_LORESERVE - 1)
4729         count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4730     }
4731
4732   /* Write out the section header names.  */
4733   if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4734       || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
4735     return FALSE;
4736
4737   if (bed->elf_backend_final_write_processing)
4738     (*bed->elf_backend_final_write_processing) (abfd,
4739                                                 elf_tdata (abfd)->linker);
4740
4741   return bed->s->write_shdrs_and_ehdr (abfd);
4742 }
4743
4744 bfd_boolean
4745 _bfd_elf_write_corefile_contents (bfd *abfd)
4746 {
4747   /* Hopefully this can be done just like an object file.  */
4748   return _bfd_elf_write_object_contents (abfd);
4749 }
4750
4751 /* Given a section, search the header to find them.  */
4752
4753 int
4754 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
4755 {
4756   const struct elf_backend_data *bed;
4757   int index;
4758
4759   if (elf_section_data (asect) != NULL
4760       && elf_section_data (asect)->this_idx != 0)
4761     return elf_section_data (asect)->this_idx;
4762
4763   if (bfd_is_abs_section (asect))
4764     index = SHN_ABS;
4765   else if (bfd_is_com_section (asect))
4766     index = SHN_COMMON;
4767   else if (bfd_is_und_section (asect))
4768     index = SHN_UNDEF;
4769   else
4770     {
4771       Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
4772       int maxindex = elf_numsections (abfd);
4773
4774       for (index = 1; index < maxindex; index++)
4775         {
4776           Elf_Internal_Shdr *hdr = i_shdrp[index];
4777
4778           if (hdr != NULL && hdr->bfd_section == asect)
4779             return index;
4780         }
4781       index = -1;
4782     }
4783
4784   bed = get_elf_backend_data (abfd);
4785   if (bed->elf_backend_section_from_bfd_section)
4786     {
4787       int retval = index;
4788
4789       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4790         return retval;
4791     }
4792
4793   if (index == -1)
4794     bfd_set_error (bfd_error_nonrepresentable_section);
4795
4796   return index;
4797 }
4798
4799 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4800    on error.  */
4801
4802 int
4803 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
4804 {
4805   asymbol *asym_ptr = *asym_ptr_ptr;
4806   int idx;
4807   flagword flags = asym_ptr->flags;
4808
4809   /* When gas creates relocations against local labels, it creates its
4810      own symbol for the section, but does put the symbol into the
4811      symbol chain, so udata is 0.  When the linker is generating
4812      relocatable output, this section symbol may be for one of the
4813      input sections rather than the output section.  */
4814   if (asym_ptr->udata.i == 0
4815       && (flags & BSF_SECTION_SYM)
4816       && asym_ptr->section)
4817     {
4818       int indx;
4819
4820       if (asym_ptr->section->output_section != NULL)
4821         indx = asym_ptr->section->output_section->index;
4822       else
4823         indx = asym_ptr->section->index;
4824       if (indx < elf_num_section_syms (abfd)
4825           && elf_section_syms (abfd)[indx] != NULL)
4826         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4827     }
4828
4829   idx = asym_ptr->udata.i;
4830
4831   if (idx == 0)
4832     {
4833       /* This case can occur when using --strip-symbol on a symbol
4834          which is used in a relocation entry.  */
4835       (*_bfd_error_handler)
4836         (_("%B: symbol `%s' required but not present"),
4837          abfd, bfd_asymbol_name (asym_ptr));
4838       bfd_set_error (bfd_error_no_symbols);
4839       return -1;
4840     }
4841
4842 #if DEBUG & 4
4843   {
4844     fprintf (stderr,
4845              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4846              (long) asym_ptr, asym_ptr->name, idx, flags,
4847              elf_symbol_flags (flags));
4848     fflush (stderr);
4849   }
4850 #endif
4851
4852   return idx;
4853 }
4854
4855 /* Copy private BFD data.  This copies any program header information.  */
4856
4857 static bfd_boolean
4858 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4859 {
4860   Elf_Internal_Ehdr *iehdr;
4861   struct elf_segment_map *map;
4862   struct elf_segment_map *map_first;
4863   struct elf_segment_map **pointer_to_map;
4864   Elf_Internal_Phdr *segment;
4865   asection *section;
4866   unsigned int i;
4867   unsigned int num_segments;
4868   bfd_boolean phdr_included = FALSE;
4869   bfd_vma maxpagesize;
4870   struct elf_segment_map *phdr_adjust_seg = NULL;
4871   unsigned int phdr_adjust_num = 0;
4872   const struct elf_backend_data *bed;
4873
4874   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4875       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4876     return TRUE;
4877
4878   if (elf_tdata (ibfd)->phdr == NULL)
4879     return TRUE;
4880
4881   bed = get_elf_backend_data (ibfd);
4882   iehdr = elf_elfheader (ibfd);
4883
4884   map_first = NULL;
4885   pointer_to_map = &map_first;
4886
4887   num_segments = elf_elfheader (ibfd)->e_phnum;
4888   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4889
4890   /* Returns the end address of the segment + 1.  */
4891 #define SEGMENT_END(segment, start)                                     \
4892   (start + (segment->p_memsz > segment->p_filesz                        \
4893             ? segment->p_memsz : segment->p_filesz))
4894
4895 #define SECTION_SIZE(section, segment)                                  \
4896   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
4897     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
4898    ? section->size : 0)
4899
4900   /* Returns TRUE if the given section is contained within
4901      the given segment.  VMA addresses are compared.  */
4902 #define IS_CONTAINED_BY_VMA(section, segment)                           \
4903   (section->vma >= segment->p_vaddr                                     \
4904    && (section->vma + SECTION_SIZE (section, segment)                   \
4905        <= (SEGMENT_END (segment, segment->p_vaddr))))
4906
4907   /* Returns TRUE if the given section is contained within
4908      the given segment.  LMA addresses are compared.  */
4909 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
4910   (section->lma >= base                                                 \
4911    && (section->lma + SECTION_SIZE (section, segment)                   \
4912        <= SEGMENT_END (segment, base)))
4913
4914   /* Special case: corefile "NOTE" section containing regs, prpsinfo etc.  */
4915 #define IS_COREFILE_NOTE(p, s)                                          \
4916   (p->p_type == PT_NOTE                                                 \
4917    && bfd_get_format (ibfd) == bfd_core                                 \
4918    && s->vma == 0 && s->lma == 0                                        \
4919    && (bfd_vma) s->filepos >= p->p_offset                               \
4920    && ((bfd_vma) s->filepos + s->size                           \
4921        <= p->p_offset + p->p_filesz))
4922
4923   /* The complicated case when p_vaddr is 0 is to handle the Solaris
4924      linker, which generates a PT_INTERP section with p_vaddr and
4925      p_memsz set to 0.  */
4926 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
4927   (p->p_vaddr == 0                                                      \
4928    && p->p_paddr == 0                                                   \
4929    && p->p_memsz == 0                                                   \
4930    && p->p_filesz > 0                                                   \
4931    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
4932    && s->size > 0                                                       \
4933    && (bfd_vma) s->filepos >= p->p_offset                               \
4934    && ((bfd_vma) s->filepos + s->size                           \
4935        <= p->p_offset + p->p_filesz))
4936
4937   /* Decide if the given section should be included in the given segment.
4938      A section will be included if:
4939        1. It is within the address space of the segment -- we use the LMA
4940           if that is set for the segment and the VMA otherwise,
4941        2. It is an allocated segment,
4942        3. There is an output section associated with it,
4943        4. The section has not already been allocated to a previous segment.
4944        5. PT_GNU_STACK segments do not include any sections.
4945        6. PT_TLS segment includes only SHF_TLS sections.
4946        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.  */
4947 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
4948   ((((segment->p_paddr                                                  \
4949       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
4950       : IS_CONTAINED_BY_VMA (section, segment))                         \
4951      && (section->flags & SEC_ALLOC) != 0)                              \
4952     || IS_COREFILE_NOTE (segment, section))                             \
4953    && section->output_section != NULL                                   \
4954    && segment->p_type != PT_GNU_STACK                                   \
4955    && (segment->p_type != PT_TLS                                        \
4956        || (section->flags & SEC_THREAD_LOCAL))                          \
4957    && (segment->p_type == PT_LOAD                                       \
4958        || segment->p_type == PT_TLS                                     \
4959        || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
4960    && ! section->segment_mark)
4961
4962   /* Returns TRUE iff seg1 starts after the end of seg2.  */
4963 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
4964   (seg1->field >= SEGMENT_END (seg2, seg2->field))
4965
4966   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
4967      their VMA address ranges and their LMA address ranges overlap.
4968      It is possible to have overlapping VMA ranges without overlapping LMA
4969      ranges.  RedBoot images for example can have both .data and .bss mapped
4970      to the same VMA range, but with the .data section mapped to a different
4971      LMA.  */
4972 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
4973   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
4974         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
4975    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
4976         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
4977
4978   /* Initialise the segment mark field.  */
4979   for (section = ibfd->sections; section != NULL; section = section->next)
4980     section->segment_mark = FALSE;
4981
4982   /* Scan through the segments specified in the program header
4983      of the input BFD.  For this first scan we look for overlaps
4984      in the loadable segments.  These can be created by weird
4985      parameters to objcopy.  Also, fix some solaris weirdness.  */
4986   for (i = 0, segment = elf_tdata (ibfd)->phdr;
4987        i < num_segments;
4988        i++, segment++)
4989     {
4990       unsigned int j;
4991       Elf_Internal_Phdr *segment2;
4992
4993       if (segment->p_type == PT_INTERP)
4994         for (section = ibfd->sections; section; section = section->next)
4995           if (IS_SOLARIS_PT_INTERP (segment, section))
4996             {
4997               /* Mininal change so that the normal section to segment
4998                  assignment code will work.  */
4999               segment->p_vaddr = section->vma;
5000               break;
5001             }
5002
5003       if (segment->p_type != PT_LOAD)
5004         continue;
5005
5006       /* Determine if this segment overlaps any previous segments.  */
5007       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
5008         {
5009           bfd_signed_vma extra_length;
5010
5011           if (segment2->p_type != PT_LOAD
5012               || ! SEGMENT_OVERLAPS (segment, segment2))
5013             continue;
5014
5015           /* Merge the two segments together.  */
5016           if (segment2->p_vaddr < segment->p_vaddr)
5017             {
5018               /* Extend SEGMENT2 to include SEGMENT and then delete
5019                  SEGMENT.  */
5020               extra_length =
5021                 SEGMENT_END (segment, segment->p_vaddr)
5022                 - SEGMENT_END (segment2, segment2->p_vaddr);
5023
5024               if (extra_length > 0)
5025                 {
5026                   segment2->p_memsz  += extra_length;
5027                   segment2->p_filesz += extra_length;
5028                 }
5029
5030               segment->p_type = PT_NULL;
5031
5032               /* Since we have deleted P we must restart the outer loop.  */
5033               i = 0;
5034               segment = elf_tdata (ibfd)->phdr;
5035               break;
5036             }
5037           else
5038             {
5039               /* Extend SEGMENT to include SEGMENT2 and then delete
5040                  SEGMENT2.  */
5041               extra_length =
5042                 SEGMENT_END (segment2, segment2->p_vaddr)
5043                 - SEGMENT_END (segment, segment->p_vaddr);
5044
5045               if (extra_length > 0)
5046                 {
5047                   segment->p_memsz  += extra_length;
5048                   segment->p_filesz += extra_length;
5049                 }
5050
5051               segment2->p_type = PT_NULL;
5052             }
5053         }
5054     }
5055
5056   /* The second scan attempts to assign sections to segments.  */
5057   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5058        i < num_segments;
5059        i ++, segment ++)
5060     {
5061       unsigned int  section_count;
5062       asection **   sections;
5063       asection *    output_section;
5064       unsigned int  isec;
5065       bfd_vma       matching_lma;
5066       bfd_vma       suggested_lma;
5067       unsigned int  j;
5068       bfd_size_type amt;
5069
5070       if (segment->p_type == PT_NULL)
5071         continue;
5072
5073       /* Compute how many sections might be placed into this segment.  */
5074       for (section = ibfd->sections, section_count = 0;
5075            section != NULL;
5076            section = section->next)
5077         if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5078           ++section_count;
5079
5080       /* Allocate a segment map big enough to contain
5081          all of the sections we have selected.  */
5082       amt = sizeof (struct elf_segment_map);
5083       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5084       map = bfd_alloc (obfd, amt);
5085       if (map == NULL)
5086         return FALSE;
5087
5088       /* Initialise the fields of the segment map.  Default to
5089          using the physical address of the segment in the input BFD.  */
5090       map->next          = NULL;
5091       map->p_type        = segment->p_type;
5092       map->p_flags       = segment->p_flags;
5093       map->p_flags_valid = 1;
5094       map->p_paddr       = segment->p_paddr;
5095       map->p_paddr_valid = 1;
5096
5097       /* Determine if this segment contains the ELF file header
5098          and if it contains the program headers themselves.  */
5099       map->includes_filehdr = (segment->p_offset == 0
5100                                && segment->p_filesz >= iehdr->e_ehsize);
5101
5102       map->includes_phdrs = 0;
5103
5104       if (! phdr_included || segment->p_type != PT_LOAD)
5105         {
5106           map->includes_phdrs =
5107             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5108              && (segment->p_offset + segment->p_filesz
5109                  >= ((bfd_vma) iehdr->e_phoff
5110                      + iehdr->e_phnum * iehdr->e_phentsize)));
5111
5112           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5113             phdr_included = TRUE;
5114         }
5115
5116       if (section_count == 0)
5117         {
5118           /* Special segments, such as the PT_PHDR segment, may contain
5119              no sections, but ordinary, loadable segments should contain
5120              something.  They are allowed by the ELF spec however, so only
5121              a warning is produced.  */
5122           if (segment->p_type == PT_LOAD)
5123             (*_bfd_error_handler)
5124               (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5125                ibfd);
5126
5127           map->count = 0;
5128           *pointer_to_map = map;
5129           pointer_to_map = &map->next;
5130
5131           continue;
5132         }
5133
5134       /* Now scan the sections in the input BFD again and attempt
5135          to add their corresponding output sections to the segment map.
5136          The problem here is how to handle an output section which has
5137          been moved (ie had its LMA changed).  There are four possibilities:
5138
5139          1. None of the sections have been moved.
5140             In this case we can continue to use the segment LMA from the
5141             input BFD.
5142
5143          2. All of the sections have been moved by the same amount.
5144             In this case we can change the segment's LMA to match the LMA
5145             of the first section.
5146
5147          3. Some of the sections have been moved, others have not.
5148             In this case those sections which have not been moved can be
5149             placed in the current segment which will have to have its size,
5150             and possibly its LMA changed, and a new segment or segments will
5151             have to be created to contain the other sections.
5152
5153          4. The sections have been moved, but not by the same amount.
5154             In this case we can change the segment's LMA to match the LMA
5155             of the first section and we will have to create a new segment
5156             or segments to contain the other sections.
5157
5158          In order to save time, we allocate an array to hold the section
5159          pointers that we are interested in.  As these sections get assigned
5160          to a segment, they are removed from this array.  */
5161
5162       /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5163          to work around this long long bug.  */
5164       amt = section_count * sizeof (asection *);
5165       sections = bfd_malloc (amt);
5166       if (sections == NULL)
5167         return FALSE;
5168
5169       /* Step One: Scan for segment vs section LMA conflicts.
5170          Also add the sections to the section array allocated above.
5171          Also add the sections to the current segment.  In the common
5172          case, where the sections have not been moved, this means that
5173          we have completely filled the segment, and there is nothing
5174          more to do.  */
5175       isec = 0;
5176       matching_lma = 0;
5177       suggested_lma = 0;
5178
5179       for (j = 0, section = ibfd->sections;
5180            section != NULL;
5181            section = section->next)
5182         {
5183           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5184             {
5185               output_section = section->output_section;
5186
5187               sections[j ++] = section;
5188
5189               /* The Solaris native linker always sets p_paddr to 0.
5190                  We try to catch that case here, and set it to the
5191                  correct value.  Note - some backends require that
5192                  p_paddr be left as zero.  */
5193               if (segment->p_paddr == 0
5194                   && segment->p_vaddr != 0
5195                   && (! bed->want_p_paddr_set_to_zero)
5196                   && isec == 0
5197                   && output_section->lma != 0
5198                   && (output_section->vma == (segment->p_vaddr
5199                                               + (map->includes_filehdr
5200                                                  ? iehdr->e_ehsize
5201                                                  : 0)
5202                                               + (map->includes_phdrs
5203                                                  ? (iehdr->e_phnum
5204                                                     * iehdr->e_phentsize)
5205                                                  : 0))))
5206                 map->p_paddr = segment->p_vaddr;
5207
5208               /* Match up the physical address of the segment with the
5209                  LMA address of the output section.  */
5210               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5211                   || IS_COREFILE_NOTE (segment, section)
5212                   || (bed->want_p_paddr_set_to_zero &&
5213                       IS_CONTAINED_BY_VMA (output_section, segment))
5214                 )
5215                 {
5216                   if (matching_lma == 0)
5217                     matching_lma = output_section->lma;
5218
5219                   /* We assume that if the section fits within the segment
5220                      then it does not overlap any other section within that
5221                      segment.  */
5222                   map->sections[isec ++] = output_section;
5223                 }
5224               else if (suggested_lma == 0)
5225                 suggested_lma = output_section->lma;
5226             }
5227         }
5228
5229       BFD_ASSERT (j == section_count);
5230
5231       /* Step Two: Adjust the physical address of the current segment,
5232          if necessary.  */
5233       if (isec == section_count)
5234         {
5235           /* All of the sections fitted within the segment as currently
5236              specified.  This is the default case.  Add the segment to
5237              the list of built segments and carry on to process the next
5238              program header in the input BFD.  */
5239           map->count = section_count;
5240           *pointer_to_map = map;
5241           pointer_to_map = &map->next;
5242
5243           free (sections);
5244           continue;
5245         }
5246       else
5247         {
5248           if (matching_lma != 0)
5249             {
5250               /* At least one section fits inside the current segment.
5251                  Keep it, but modify its physical address to match the
5252                  LMA of the first section that fitted.  */
5253               map->p_paddr = matching_lma;
5254             }
5255           else
5256             {
5257               /* None of the sections fitted inside the current segment.
5258                  Change the current segment's physical address to match
5259                  the LMA of the first section.  */
5260               map->p_paddr = suggested_lma;
5261             }
5262
5263           /* Offset the segment physical address from the lma
5264              to allow for space taken up by elf headers.  */
5265           if (map->includes_filehdr)
5266             map->p_paddr -= iehdr->e_ehsize;
5267
5268           if (map->includes_phdrs)
5269             {
5270               map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5271
5272               /* iehdr->e_phnum is just an estimate of the number
5273                  of program headers that we will need.  Make a note
5274                  here of the number we used and the segment we chose
5275                  to hold these headers, so that we can adjust the
5276                  offset when we know the correct value.  */
5277               phdr_adjust_num = iehdr->e_phnum;
5278               phdr_adjust_seg = map;
5279             }
5280         }
5281
5282       /* Step Three: Loop over the sections again, this time assigning
5283          those that fit to the current segment and removing them from the
5284          sections array; but making sure not to leave large gaps.  Once all
5285          possible sections have been assigned to the current segment it is
5286          added to the list of built segments and if sections still remain
5287          to be assigned, a new segment is constructed before repeating
5288          the loop.  */
5289       isec = 0;
5290       do
5291         {
5292           map->count = 0;
5293           suggested_lma = 0;
5294
5295           /* Fill the current segment with sections that fit.  */
5296           for (j = 0; j < section_count; j++)
5297             {
5298               section = sections[j];
5299
5300               if (section == NULL)
5301                 continue;
5302
5303               output_section = section->output_section;
5304
5305               BFD_ASSERT (output_section != NULL);
5306
5307               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5308                   || IS_COREFILE_NOTE (segment, section))
5309                 {
5310                   if (map->count == 0)
5311                     {
5312                       /* If the first section in a segment does not start at
5313                          the beginning of the segment, then something is
5314                          wrong.  */
5315                       if (output_section->lma !=
5316                           (map->p_paddr
5317                            + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5318                            + (map->includes_phdrs
5319                               ? iehdr->e_phnum * iehdr->e_phentsize
5320                               : 0)))
5321                         abort ();
5322                     }
5323                   else
5324                     {
5325                       asection * prev_sec;
5326
5327                       prev_sec = map->sections[map->count - 1];
5328
5329                       /* If the gap between the end of the previous section
5330                          and the start of this section is more than
5331                          maxpagesize then we need to start a new segment.  */
5332                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5333                                       maxpagesize)
5334                            < BFD_ALIGN (output_section->lma, maxpagesize))
5335                           || ((prev_sec->lma + prev_sec->size)
5336                               > output_section->lma))
5337                         {
5338                           if (suggested_lma == 0)
5339                             suggested_lma = output_section->lma;
5340
5341                           continue;
5342                         }
5343                     }
5344
5345                   map->sections[map->count++] = output_section;
5346                   ++isec;
5347                   sections[j] = NULL;
5348                   section->segment_mark = TRUE;
5349                 }
5350               else if (suggested_lma == 0)
5351                 suggested_lma = output_section->lma;
5352             }
5353
5354           BFD_ASSERT (map->count > 0);
5355
5356           /* Add the current segment to the list of built segments.  */
5357           *pointer_to_map = map;
5358           pointer_to_map = &map->next;
5359
5360           if (isec < section_count)
5361             {
5362               /* We still have not allocated all of the sections to
5363                  segments.  Create a new segment here, initialise it
5364                  and carry on looping.  */
5365               amt = sizeof (struct elf_segment_map);
5366               amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5367               map = bfd_alloc (obfd, amt);
5368               if (map == NULL)
5369                 {
5370                   free (sections);
5371                   return FALSE;
5372                 }
5373
5374               /* Initialise the fields of the segment map.  Set the physical
5375                  physical address to the LMA of the first section that has
5376                  not yet been assigned.  */
5377               map->next             = NULL;
5378               map->p_type           = segment->p_type;
5379               map->p_flags          = segment->p_flags;
5380               map->p_flags_valid    = 1;
5381               map->p_paddr          = suggested_lma;
5382               map->p_paddr_valid    = 1;
5383               map->includes_filehdr = 0;
5384               map->includes_phdrs   = 0;
5385             }
5386         }
5387       while (isec < section_count);
5388
5389       free (sections);
5390     }
5391
5392   /* The Solaris linker creates program headers in which all the
5393      p_paddr fields are zero.  When we try to objcopy or strip such a
5394      file, we get confused.  Check for this case, and if we find it
5395      reset the p_paddr_valid fields.  */
5396   for (map = map_first; map != NULL; map = map->next)
5397     if (map->p_paddr != 0)
5398       break;
5399   if (map == NULL)
5400     for (map = map_first; map != NULL; map = map->next)
5401       map->p_paddr_valid = 0;
5402
5403   elf_tdata (obfd)->segment_map = map_first;
5404
5405   /* If we had to estimate the number of program headers that were
5406      going to be needed, then check our estimate now and adjust
5407      the offset if necessary.  */
5408   if (phdr_adjust_seg != NULL)
5409     {
5410       unsigned int count;
5411
5412       for (count = 0, map = map_first; map != NULL; map = map->next)
5413         count++;
5414
5415       if (count > phdr_adjust_num)
5416         phdr_adjust_seg->p_paddr
5417           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5418     }
5419
5420 #if 0
5421   /* Final Step: Sort the segments into ascending order of physical
5422      address.  */
5423   if (map_first != NULL)
5424     {
5425       struct elf_segment_map *prev;
5426
5427       prev = map_first;
5428       for (map = map_first->next; map != NULL; prev = map, map = map->next)
5429         {
5430           /* Yes I know - its a bubble sort....  */
5431           if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
5432             {
5433               /* Swap map and map->next.  */
5434               prev->next = map->next;
5435               map->next = map->next->next;
5436               prev->next->next = map;
5437
5438               /* Restart loop.  */
5439               map = map_first;
5440             }
5441         }
5442     }
5443 #endif
5444
5445 #undef SEGMENT_END
5446 #undef SECTION_SIZE
5447 #undef IS_CONTAINED_BY_VMA
5448 #undef IS_CONTAINED_BY_LMA
5449 #undef IS_COREFILE_NOTE
5450 #undef IS_SOLARIS_PT_INTERP
5451 #undef INCLUDE_SECTION_IN_SEGMENT
5452 #undef SEGMENT_AFTER_SEGMENT
5453 #undef SEGMENT_OVERLAPS
5454   return TRUE;
5455 }
5456
5457 /* Copy private section information.  This copies over the entsize
5458    field, and sometimes the info field.  */
5459
5460 bfd_boolean
5461 _bfd_elf_copy_private_section_data (bfd *ibfd,
5462                                     asection *isec,
5463                                     bfd *obfd,
5464                                     asection *osec)
5465 {
5466   Elf_Internal_Shdr *ihdr, *ohdr;
5467
5468   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5469       || obfd->xvec->flavour != bfd_target_elf_flavour)
5470     return TRUE;
5471
5472   ihdr = &elf_section_data (isec)->this_hdr;
5473   ohdr = &elf_section_data (osec)->this_hdr;
5474
5475   ohdr->sh_entsize = ihdr->sh_entsize;
5476
5477   if (ihdr->sh_type == SHT_SYMTAB
5478       || ihdr->sh_type == SHT_DYNSYM
5479       || ihdr->sh_type == SHT_GNU_verneed
5480       || ihdr->sh_type == SHT_GNU_verdef)
5481     ohdr->sh_info = ihdr->sh_info;
5482
5483   /* Set things up for objcopy.  The output SHT_GROUP section will
5484      have its elf_next_in_group pointing back to the input group
5485      members.  */
5486   elf_next_in_group (osec) = elf_next_in_group (isec);
5487   elf_group_name (osec) = elf_group_name (isec);
5488
5489   osec->use_rela_p = isec->use_rela_p;
5490
5491   return TRUE;
5492 }
5493
5494 /* Copy private header information.  */
5495
5496 bfd_boolean
5497 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
5498 {
5499   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5500       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5501     return TRUE;
5502
5503   /* Copy over private BFD data if it has not already been copied.
5504      This must be done here, rather than in the copy_private_bfd_data
5505      entry point, because the latter is called after the section
5506      contents have been set, which means that the program headers have
5507      already been worked out.  */
5508   if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5509     {
5510       if (! copy_private_bfd_data (ibfd, obfd))
5511         return FALSE;
5512     }
5513
5514   return TRUE;
5515 }
5516
5517 /* Copy private symbol information.  If this symbol is in a section
5518    which we did not map into a BFD section, try to map the section
5519    index correctly.  We use special macro definitions for the mapped
5520    section indices; these definitions are interpreted by the
5521    swap_out_syms function.  */
5522
5523 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5524 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5525 #define MAP_STRTAB    (SHN_HIOS + 3)
5526 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
5527 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5528
5529 bfd_boolean
5530 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
5531                                    asymbol *isymarg,
5532                                    bfd *obfd,
5533                                    asymbol *osymarg)
5534 {
5535   elf_symbol_type *isym, *osym;
5536
5537   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5538       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5539     return TRUE;
5540
5541   isym = elf_symbol_from (ibfd, isymarg);
5542   osym = elf_symbol_from (obfd, osymarg);
5543
5544   if (isym != NULL
5545       && osym != NULL
5546       && bfd_is_abs_section (isym->symbol.section))
5547     {
5548       unsigned int shndx;
5549
5550       shndx = isym->internal_elf_sym.st_shndx;
5551       if (shndx == elf_onesymtab (ibfd))
5552         shndx = MAP_ONESYMTAB;
5553       else if (shndx == elf_dynsymtab (ibfd))
5554         shndx = MAP_DYNSYMTAB;
5555       else if (shndx == elf_tdata (ibfd)->strtab_section)
5556         shndx = MAP_STRTAB;
5557       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5558         shndx = MAP_SHSTRTAB;
5559       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5560         shndx = MAP_SYM_SHNDX;
5561       osym->internal_elf_sym.st_shndx = shndx;
5562     }
5563
5564   return TRUE;
5565 }
5566
5567 /* Swap out the symbols.  */
5568
5569 static bfd_boolean
5570 swap_out_syms (bfd *abfd,
5571                struct bfd_strtab_hash **sttp,
5572                int relocatable_p)
5573 {
5574   const struct elf_backend_data *bed;
5575   int symcount;
5576   asymbol **syms;
5577   struct bfd_strtab_hash *stt;
5578   Elf_Internal_Shdr *symtab_hdr;
5579   Elf_Internal_Shdr *symtab_shndx_hdr;
5580   Elf_Internal_Shdr *symstrtab_hdr;
5581   char *outbound_syms;
5582   char *outbound_shndx;
5583   int idx;
5584   bfd_size_type amt;
5585   bfd_boolean name_local_sections;
5586
5587   if (!elf_map_symbols (abfd))
5588     return FALSE;
5589
5590   /* Dump out the symtabs.  */
5591   stt = _bfd_elf_stringtab_init ();
5592   if (stt == NULL)
5593     return FALSE;
5594
5595   bed = get_elf_backend_data (abfd);
5596   symcount = bfd_get_symcount (abfd);
5597   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5598   symtab_hdr->sh_type = SHT_SYMTAB;
5599   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5600   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5601   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5602   symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
5603
5604   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5605   symstrtab_hdr->sh_type = SHT_STRTAB;
5606
5607   amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
5608   outbound_syms = bfd_alloc (abfd, amt);
5609   if (outbound_syms == NULL)
5610     {
5611       _bfd_stringtab_free (stt);
5612       return FALSE;
5613     }
5614   symtab_hdr->contents = outbound_syms;
5615
5616   outbound_shndx = NULL;
5617   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5618   if (symtab_shndx_hdr->sh_name != 0)
5619     {
5620       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5621       outbound_shndx = bfd_zalloc (abfd, amt);
5622       if (outbound_shndx == NULL)
5623         {
5624           _bfd_stringtab_free (stt);
5625           return FALSE;
5626         }
5627
5628       symtab_shndx_hdr->contents = outbound_shndx;
5629       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5630       symtab_shndx_hdr->sh_size = amt;
5631       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5632       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5633     }
5634
5635   /* Now generate the data (for "contents").  */
5636   {
5637     /* Fill in zeroth symbol and swap it out.  */
5638     Elf_Internal_Sym sym;
5639     sym.st_name = 0;
5640     sym.st_value = 0;
5641     sym.st_size = 0;
5642     sym.st_info = 0;
5643     sym.st_other = 0;
5644     sym.st_shndx = SHN_UNDEF;
5645     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5646     outbound_syms += bed->s->sizeof_sym;
5647     if (outbound_shndx != NULL)
5648       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5649   }
5650
5651   name_local_sections
5652     = (bed->elf_backend_name_local_section_symbols
5653        && bed->elf_backend_name_local_section_symbols (abfd));
5654
5655   syms = bfd_get_outsymbols (abfd);
5656   for (idx = 0; idx < symcount; idx++)
5657     {
5658       Elf_Internal_Sym sym;
5659       bfd_vma value = syms[idx]->value;
5660       elf_symbol_type *type_ptr;
5661       flagword flags = syms[idx]->flags;
5662       int type;
5663
5664       if (!name_local_sections
5665           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5666         {
5667           /* Local section symbols have no name.  */
5668           sym.st_name = 0;
5669         }
5670       else
5671         {
5672           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5673                                                             syms[idx]->name,
5674                                                             TRUE, FALSE);
5675           if (sym.st_name == (unsigned long) -1)
5676             {
5677               _bfd_stringtab_free (stt);
5678               return FALSE;
5679             }
5680         }
5681
5682       type_ptr = elf_symbol_from (abfd, syms[idx]);
5683
5684       if ((flags & BSF_SECTION_SYM) == 0
5685           && bfd_is_com_section (syms[idx]->section))
5686         {
5687           /* ELF common symbols put the alignment into the `value' field,
5688              and the size into the `size' field.  This is backwards from
5689              how BFD handles it, so reverse it here.  */
5690           sym.st_size = value;
5691           if (type_ptr == NULL
5692               || type_ptr->internal_elf_sym.st_value == 0)
5693             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5694           else
5695             sym.st_value = type_ptr->internal_elf_sym.st_value;
5696           sym.st_shndx = _bfd_elf_section_from_bfd_section
5697             (abfd, syms[idx]->section);
5698         }
5699       else
5700         {
5701           asection *sec = syms[idx]->section;
5702           int shndx;
5703
5704           if (sec->output_section)
5705             {
5706               value += sec->output_offset;
5707               sec = sec->output_section;
5708             }
5709
5710           /* Don't add in the section vma for relocatable output.  */
5711           if (! relocatable_p)
5712             value += sec->vma;
5713           sym.st_value = value;
5714           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5715
5716           if (bfd_is_abs_section (sec)
5717               && type_ptr != NULL
5718               && type_ptr->internal_elf_sym.st_shndx != 0)
5719             {
5720               /* This symbol is in a real ELF section which we did
5721                  not create as a BFD section.  Undo the mapping done
5722                  by copy_private_symbol_data.  */
5723               shndx = type_ptr->internal_elf_sym.st_shndx;
5724               switch (shndx)
5725                 {
5726                 case MAP_ONESYMTAB:
5727                   shndx = elf_onesymtab (abfd);
5728                   break;
5729                 case MAP_DYNSYMTAB:
5730                   shndx = elf_dynsymtab (abfd);
5731                   break;
5732                 case MAP_STRTAB:
5733                   shndx = elf_tdata (abfd)->strtab_section;
5734                   break;
5735                 case MAP_SHSTRTAB:
5736                   shndx = elf_tdata (abfd)->shstrtab_section;
5737                   break;
5738                 case MAP_SYM_SHNDX:
5739                   shndx = elf_tdata (abfd)->symtab_shndx_section;
5740                   break;
5741                 default:
5742                   break;
5743                 }
5744             }
5745           else
5746             {
5747               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5748
5749               if (shndx == -1)
5750                 {
5751                   asection *sec2;
5752
5753                   /* Writing this would be a hell of a lot easier if
5754                      we had some decent documentation on bfd, and
5755                      knew what to expect of the library, and what to
5756                      demand of applications.  For example, it
5757                      appears that `objcopy' might not set the
5758                      section of a symbol to be a section that is
5759                      actually in the output file.  */
5760                   sec2 = bfd_get_section_by_name (abfd, sec->name);
5761                   if (sec2 == NULL)
5762                     {
5763                       _bfd_error_handler (_("\
5764 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5765                                           syms[idx]->name ? syms[idx]->name : "<Local sym>",
5766                                           sec->name);
5767                       bfd_set_error (bfd_error_invalid_operation);
5768                       _bfd_stringtab_free (stt);
5769                       return FALSE;
5770                     }
5771
5772                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5773                   BFD_ASSERT (shndx != -1);
5774                 }
5775             }
5776
5777           sym.st_shndx = shndx;
5778         }
5779
5780       if ((flags & BSF_THREAD_LOCAL) != 0)
5781         type = STT_TLS;
5782       else if ((flags & BSF_FUNCTION) != 0)
5783         type = STT_FUNC;
5784       else if ((flags & BSF_OBJECT) != 0)
5785         type = STT_OBJECT;
5786       else
5787         type = STT_NOTYPE;
5788
5789       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
5790         type = STT_TLS;
5791
5792       /* Processor-specific types.  */
5793       if (type_ptr != NULL
5794           && bed->elf_backend_get_symbol_type)
5795         type = ((*bed->elf_backend_get_symbol_type)
5796                 (&type_ptr->internal_elf_sym, type));
5797
5798       if (flags & BSF_SECTION_SYM)
5799         {
5800           if (flags & BSF_GLOBAL)
5801             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5802           else
5803             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5804         }
5805       else if (bfd_is_com_section (syms[idx]->section))
5806         sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5807       else if (bfd_is_und_section (syms[idx]->section))
5808         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5809                                     ? STB_WEAK
5810                                     : STB_GLOBAL),
5811                                    type);
5812       else if (flags & BSF_FILE)
5813         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5814       else
5815         {
5816           int bind = STB_LOCAL;
5817
5818           if (flags & BSF_LOCAL)
5819             bind = STB_LOCAL;
5820           else if (flags & BSF_WEAK)
5821             bind = STB_WEAK;
5822           else if (flags & BSF_GLOBAL)
5823             bind = STB_GLOBAL;
5824
5825           sym.st_info = ELF_ST_INFO (bind, type);
5826         }
5827
5828       if (type_ptr != NULL)
5829         sym.st_other = type_ptr->internal_elf_sym.st_other;
5830       else
5831         sym.st_other = 0;
5832
5833       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5834       outbound_syms += bed->s->sizeof_sym;
5835       if (outbound_shndx != NULL)
5836         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5837     }
5838
5839   *sttp = stt;
5840   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
5841   symstrtab_hdr->sh_type = SHT_STRTAB;
5842
5843   symstrtab_hdr->sh_flags = 0;
5844   symstrtab_hdr->sh_addr = 0;
5845   symstrtab_hdr->sh_entsize = 0;
5846   symstrtab_hdr->sh_link = 0;
5847   symstrtab_hdr->sh_info = 0;
5848   symstrtab_hdr->sh_addralign = 1;
5849
5850   return TRUE;
5851 }
5852
5853 /* Return the number of bytes required to hold the symtab vector.
5854
5855    Note that we base it on the count plus 1, since we will null terminate
5856    the vector allocated based on this size.  However, the ELF symbol table
5857    always has a dummy entry as symbol #0, so it ends up even.  */
5858
5859 long
5860 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
5861 {
5862   long symcount;
5863   long symtab_size;
5864   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
5865
5866   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5867   symtab_size = (symcount + 1) * (sizeof (asymbol *));
5868   if (symcount > 0)
5869     symtab_size -= sizeof (asymbol *);
5870
5871   return symtab_size;
5872 }
5873
5874 long
5875 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
5876 {
5877   long symcount;
5878   long symtab_size;
5879   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
5880
5881   if (elf_dynsymtab (abfd) == 0)
5882     {
5883       bfd_set_error (bfd_error_invalid_operation);
5884       return -1;
5885     }
5886
5887   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5888   symtab_size = (symcount + 1) * (sizeof (asymbol *));
5889   if (symcount > 0)
5890     symtab_size -= sizeof (asymbol *);
5891
5892   return symtab_size;
5893 }
5894
5895 long
5896 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
5897                                 sec_ptr asect)
5898 {
5899   return (asect->reloc_count + 1) * sizeof (arelent *);
5900 }
5901
5902 /* Canonicalize the relocs.  */
5903
5904 long
5905 _bfd_elf_canonicalize_reloc (bfd *abfd,
5906                              sec_ptr section,
5907                              arelent **relptr,
5908                              asymbol **symbols)
5909 {
5910   arelent *tblptr;
5911   unsigned int i;
5912   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5913
5914   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
5915     return -1;
5916
5917   tblptr = section->relocation;
5918   for (i = 0; i < section->reloc_count; i++)
5919     *relptr++ = tblptr++;
5920
5921   *relptr = NULL;
5922
5923   return section->reloc_count;
5924 }
5925
5926 long
5927 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
5928 {
5929   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5930   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
5931
5932   if (symcount >= 0)
5933     bfd_get_symcount (abfd) = symcount;
5934   return symcount;
5935 }
5936
5937 long
5938 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
5939                                       asymbol **allocation)
5940 {
5941   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5942   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
5943
5944   if (symcount >= 0)
5945     bfd_get_dynamic_symcount (abfd) = symcount;
5946   return symcount;
5947 }
5948
5949 /* Return the size required for the dynamic reloc entries.  Any
5950    section that was actually installed in the BFD, and has type
5951    SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5952    considered to be a dynamic reloc section.  */
5953
5954 long
5955 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
5956 {
5957   long ret;
5958   asection *s;
5959
5960   if (elf_dynsymtab (abfd) == 0)
5961     {
5962       bfd_set_error (bfd_error_invalid_operation);
5963       return -1;
5964     }
5965
5966   ret = sizeof (arelent *);
5967   for (s = abfd->sections; s != NULL; s = s->next)
5968     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5969         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5970             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5971       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
5972               * sizeof (arelent *));
5973
5974   return ret;
5975 }
5976
5977 /* Canonicalize the dynamic relocation entries.  Note that we return
5978    the dynamic relocations as a single block, although they are
5979    actually associated with particular sections; the interface, which
5980    was designed for SunOS style shared libraries, expects that there
5981    is only one set of dynamic relocs.  Any section that was actually
5982    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5983    the dynamic symbol table, is considered to be a dynamic reloc
5984    section.  */
5985
5986 long
5987 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
5988                                      arelent **storage,
5989                                      asymbol **syms)
5990 {
5991   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5992   asection *s;
5993   long ret;
5994
5995   if (elf_dynsymtab (abfd) == 0)
5996     {
5997       bfd_set_error (bfd_error_invalid_operation);
5998       return -1;
5999     }
6000
6001   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6002   ret = 0;
6003   for (s = abfd->sections; s != NULL; s = s->next)
6004     {
6005       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6006           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6007               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6008         {
6009           arelent *p;
6010           long count, i;
6011
6012           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6013             return -1;
6014           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6015           p = s->relocation;
6016           for (i = 0; i < count; i++)
6017             *storage++ = p++;
6018           ret += count;
6019         }
6020     }
6021
6022   *storage = NULL;
6023
6024   return ret;
6025 }
6026 \f
6027 /* Read in the version information.  */
6028
6029 bfd_boolean
6030 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6031 {
6032   bfd_byte *contents = NULL;
6033   bfd_size_type amt;
6034   unsigned int freeidx = 0;
6035
6036   if (elf_dynverref (abfd) != 0)
6037     {
6038       Elf_Internal_Shdr *hdr;
6039       Elf_External_Verneed *everneed;
6040       Elf_Internal_Verneed *iverneed;
6041       unsigned int i;
6042
6043       hdr = &elf_tdata (abfd)->dynverref_hdr;
6044
6045       amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
6046       elf_tdata (abfd)->verref = bfd_zalloc (abfd, amt);
6047       if (elf_tdata (abfd)->verref == NULL)
6048         goto error_return;
6049
6050       elf_tdata (abfd)->cverrefs = hdr->sh_info;
6051
6052       contents = bfd_malloc (hdr->sh_size);
6053       if (contents == NULL)
6054         goto error_return;
6055       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6056           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6057         goto error_return;
6058
6059       everneed = (Elf_External_Verneed *) contents;
6060       iverneed = elf_tdata (abfd)->verref;
6061       for (i = 0; i < hdr->sh_info; i++, iverneed++)
6062         {
6063           Elf_External_Vernaux *evernaux;
6064           Elf_Internal_Vernaux *ivernaux;
6065           unsigned int j;
6066
6067           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6068
6069           iverneed->vn_bfd = abfd;
6070
6071           iverneed->vn_filename =
6072             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6073                                              iverneed->vn_file);
6074           if (iverneed->vn_filename == NULL)
6075             goto error_return;
6076
6077           amt = iverneed->vn_cnt;
6078           amt *= sizeof (Elf_Internal_Vernaux);
6079           iverneed->vn_auxptr = bfd_alloc (abfd, amt);
6080
6081           evernaux = ((Elf_External_Vernaux *)
6082                       ((bfd_byte *) everneed + iverneed->vn_aux));
6083           ivernaux = iverneed->vn_auxptr;
6084           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6085             {
6086               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6087
6088               ivernaux->vna_nodename =
6089                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6090                                                  ivernaux->vna_name);
6091               if (ivernaux->vna_nodename == NULL)
6092                 goto error_return;
6093
6094               if (j + 1 < iverneed->vn_cnt)
6095                 ivernaux->vna_nextptr = ivernaux + 1;
6096               else
6097                 ivernaux->vna_nextptr = NULL;
6098
6099               evernaux = ((Elf_External_Vernaux *)
6100                           ((bfd_byte *) evernaux + ivernaux->vna_next));
6101
6102               if (ivernaux->vna_other > freeidx)
6103                 freeidx = ivernaux->vna_other;
6104             }
6105
6106           if (i + 1 < hdr->sh_info)
6107             iverneed->vn_nextref = iverneed + 1;
6108           else
6109             iverneed->vn_nextref = NULL;
6110
6111           everneed = ((Elf_External_Verneed *)
6112                       ((bfd_byte *) everneed + iverneed->vn_next));
6113         }
6114
6115       free (contents);
6116       contents = NULL;
6117     }
6118
6119   if (elf_dynverdef (abfd) != 0)
6120     {
6121       Elf_Internal_Shdr *hdr;
6122       Elf_External_Verdef *everdef;
6123       Elf_Internal_Verdef *iverdef;
6124       Elf_Internal_Verdef *iverdefarr;
6125       Elf_Internal_Verdef iverdefmem;
6126       unsigned int i;
6127       unsigned int maxidx;
6128
6129       hdr = &elf_tdata (abfd)->dynverdef_hdr;
6130
6131       contents = bfd_malloc (hdr->sh_size);
6132       if (contents == NULL)
6133         goto error_return;
6134       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6135           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6136         goto error_return;
6137
6138       /* We know the number of entries in the section but not the maximum
6139          index.  Therefore we have to run through all entries and find
6140          the maximum.  */
6141       everdef = (Elf_External_Verdef *) contents;
6142       maxidx = 0;
6143       for (i = 0; i < hdr->sh_info; ++i)
6144         {
6145           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6146
6147           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6148             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6149
6150           everdef = ((Elf_External_Verdef *)
6151                      ((bfd_byte *) everdef + iverdefmem.vd_next));
6152         }
6153
6154       if (default_imported_symver)
6155         {
6156           if (freeidx > maxidx)
6157             maxidx = ++freeidx;
6158           else
6159             freeidx = ++maxidx;
6160         }
6161       amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
6162       elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
6163       if (elf_tdata (abfd)->verdef == NULL)
6164         goto error_return;
6165
6166       elf_tdata (abfd)->cverdefs = maxidx;
6167
6168       everdef = (Elf_External_Verdef *) contents;
6169       iverdefarr = elf_tdata (abfd)->verdef;
6170       for (i = 0; i < hdr->sh_info; i++)
6171         {
6172           Elf_External_Verdaux *everdaux;
6173           Elf_Internal_Verdaux *iverdaux;
6174           unsigned int j;
6175
6176           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6177
6178           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6179           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6180
6181           iverdef->vd_bfd = abfd;
6182
6183           amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
6184           iverdef->vd_auxptr = bfd_alloc (abfd, amt);
6185           if (iverdef->vd_auxptr == NULL)
6186             goto error_return;
6187
6188           everdaux = ((Elf_External_Verdaux *)
6189                       ((bfd_byte *) everdef + iverdef->vd_aux));
6190           iverdaux = iverdef->vd_auxptr;
6191           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6192             {
6193               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6194
6195               iverdaux->vda_nodename =
6196                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6197                                                  iverdaux->vda_name);
6198               if (iverdaux->vda_nodename == NULL)
6199                 goto error_return;
6200
6201               if (j + 1 < iverdef->vd_cnt)
6202                 iverdaux->vda_nextptr = iverdaux + 1;
6203               else
6204                 iverdaux->vda_nextptr = NULL;
6205
6206               everdaux = ((Elf_External_Verdaux *)
6207                           ((bfd_byte *) everdaux + iverdaux->vda_next));
6208             }
6209
6210           iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6211
6212           if (i + 1 < hdr->sh_info)
6213             iverdef->vd_nextdef = iverdef + 1;
6214           else
6215             iverdef->vd_nextdef = NULL;
6216
6217           everdef = ((Elf_External_Verdef *)
6218                      ((bfd_byte *) everdef + iverdef->vd_next));
6219         }
6220
6221       free (contents);
6222       contents = NULL;
6223     }
6224   else if (default_imported_symver)
6225     {
6226       if (freeidx < 3)
6227         freeidx = 3;
6228       else
6229         freeidx++;
6230
6231       amt = (bfd_size_type) freeidx * sizeof (Elf_Internal_Verdef);
6232       elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
6233       if (elf_tdata (abfd)->verdef == NULL)
6234         goto error_return;
6235
6236       elf_tdata (abfd)->cverdefs = freeidx;
6237     }
6238
6239   /* Create a default version based on the soname.  */
6240   if (default_imported_symver)
6241     {
6242       Elf_Internal_Verdef *iverdef;
6243       Elf_Internal_Verdaux *iverdaux;
6244
6245       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6246
6247       iverdef->vd_version = VER_DEF_CURRENT;
6248       iverdef->vd_flags = 0;
6249       iverdef->vd_ndx = freeidx;
6250       iverdef->vd_cnt = 1;
6251
6252       iverdef->vd_bfd = abfd;
6253
6254       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6255       if (iverdef->vd_nodename == NULL)
6256         goto error_return;
6257       iverdef->vd_nextdef = NULL;
6258       amt = (bfd_size_type) sizeof (Elf_Internal_Verdaux);
6259       iverdef->vd_auxptr = bfd_alloc (abfd, amt);
6260
6261       iverdaux = iverdef->vd_auxptr;
6262       iverdaux->vda_nodename = iverdef->vd_nodename;
6263       iverdaux->vda_nextptr = NULL;
6264     }
6265
6266   return TRUE;
6267
6268  error_return:
6269   if (contents != NULL)
6270     free (contents);
6271   return FALSE;
6272 }
6273 \f
6274 asymbol *
6275 _bfd_elf_make_empty_symbol (bfd *abfd)
6276 {
6277   elf_symbol_type *newsym;
6278   bfd_size_type amt = sizeof (elf_symbol_type);
6279
6280   newsym = bfd_zalloc (abfd, amt);
6281   if (!newsym)
6282     return NULL;
6283   else
6284     {
6285       newsym->symbol.the_bfd = abfd;
6286       return &newsym->symbol;
6287     }
6288 }
6289
6290 void
6291 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6292                           asymbol *symbol,
6293                           symbol_info *ret)
6294 {
6295   bfd_symbol_info (symbol, ret);
6296 }
6297
6298 /* Return whether a symbol name implies a local symbol.  Most targets
6299    use this function for the is_local_label_name entry point, but some
6300    override it.  */
6301
6302 bfd_boolean
6303 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6304                               const char *name)
6305 {
6306   /* Normal local symbols start with ``.L''.  */
6307   if (name[0] == '.' && name[1] == 'L')
6308     return TRUE;
6309
6310   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6311      DWARF debugging symbols starting with ``..''.  */
6312   if (name[0] == '.' && name[1] == '.')
6313     return TRUE;
6314
6315   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6316      emitting DWARF debugging output.  I suspect this is actually a
6317      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6318      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6319      underscore to be emitted on some ELF targets).  For ease of use,
6320      we treat such symbols as local.  */
6321   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
6322     return TRUE;
6323
6324   return FALSE;
6325 }
6326
6327 alent *
6328 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6329                      asymbol *symbol ATTRIBUTE_UNUSED)
6330 {
6331   abort ();
6332   return NULL;
6333 }
6334
6335 bfd_boolean
6336 _bfd_elf_set_arch_mach (bfd *abfd,
6337                         enum bfd_architecture arch,
6338                         unsigned long machine)
6339 {
6340   /* If this isn't the right architecture for this backend, and this
6341      isn't the generic backend, fail.  */
6342   if (arch != get_elf_backend_data (abfd)->arch
6343       && arch != bfd_arch_unknown
6344       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
6345     return FALSE;
6346
6347   return bfd_default_set_arch_mach (abfd, arch, machine);
6348 }
6349
6350 /* Find the function to a particular section and offset,
6351    for error reporting.  */
6352
6353 static bfd_boolean
6354 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6355                    asection *section,
6356                    asymbol **symbols,
6357                    bfd_vma offset,
6358                    const char **filename_ptr,
6359                    const char **functionname_ptr)
6360 {
6361   const char *filename;
6362   asymbol *func;
6363   bfd_vma low_func;
6364   asymbol **p;
6365
6366   filename = NULL;
6367   func = NULL;
6368   low_func = 0;
6369
6370   for (p = symbols; *p != NULL; p++)
6371     {
6372       elf_symbol_type *q;
6373
6374       q = (elf_symbol_type *) *p;
6375
6376       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6377         {
6378         default:
6379           break;
6380         case STT_FILE:
6381           filename = bfd_asymbol_name (&q->symbol);
6382           break;
6383         case STT_NOTYPE:
6384         case STT_FUNC:
6385           if (bfd_get_section (&q->symbol) == section
6386               && q->symbol.value >= low_func
6387               && q->symbol.value <= offset)
6388             {
6389               func = (asymbol *) q;
6390               low_func = q->symbol.value;
6391             }
6392           break;
6393         }
6394     }
6395
6396   if (func == NULL)
6397     return FALSE;
6398
6399   if (filename_ptr)
6400     *filename_ptr = filename;
6401   if (functionname_ptr)
6402     *functionname_ptr = bfd_asymbol_name (func);
6403
6404   return TRUE;
6405 }
6406
6407 /* Find the nearest line to a particular section and offset,
6408    for error reporting.  */
6409
6410 bfd_boolean
6411 _bfd_elf_find_nearest_line (bfd *abfd,
6412                             asection *section,
6413                             asymbol **symbols,
6414                             bfd_vma offset,
6415                             const char **filename_ptr,
6416                             const char **functionname_ptr,
6417                             unsigned int *line_ptr)
6418 {
6419   bfd_boolean found;
6420
6421   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6422                                      filename_ptr, functionname_ptr,
6423                                      line_ptr))
6424     {
6425       if (!*functionname_ptr)
6426         elf_find_function (abfd, section, symbols, offset,
6427                            *filename_ptr ? NULL : filename_ptr,
6428                            functionname_ptr);
6429
6430       return TRUE;
6431     }
6432
6433   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6434                                      filename_ptr, functionname_ptr,
6435                                      line_ptr, 0,
6436                                      &elf_tdata (abfd)->dwarf2_find_line_info))
6437     {
6438       if (!*functionname_ptr)
6439         elf_find_function (abfd, section, symbols, offset,
6440                            *filename_ptr ? NULL : filename_ptr,
6441                            functionname_ptr);
6442
6443       return TRUE;
6444     }
6445
6446   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6447                                              &found, filename_ptr,
6448                                              functionname_ptr, line_ptr,
6449                                              &elf_tdata (abfd)->line_info))
6450     return FALSE;
6451   if (found && (*functionname_ptr || *line_ptr))
6452     return TRUE;
6453
6454   if (symbols == NULL)
6455     return FALSE;
6456
6457   if (! elf_find_function (abfd, section, symbols, offset,
6458                            filename_ptr, functionname_ptr))
6459     return FALSE;
6460
6461   *line_ptr = 0;
6462   return TRUE;
6463 }
6464
6465 int
6466 _bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
6467 {
6468   int ret;
6469
6470   ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6471   if (! reloc)
6472     ret += get_program_header_size (abfd);
6473   return ret;
6474 }
6475
6476 bfd_boolean
6477 _bfd_elf_set_section_contents (bfd *abfd,
6478                                sec_ptr section,
6479                                const void *location,
6480                                file_ptr offset,
6481                                bfd_size_type count)
6482 {
6483   Elf_Internal_Shdr *hdr;
6484   bfd_signed_vma pos;
6485
6486   if (! abfd->output_has_begun
6487       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6488     return FALSE;
6489
6490   hdr = &elf_section_data (section)->this_hdr;
6491   pos = hdr->sh_offset + offset;
6492   if (bfd_seek (abfd, pos, SEEK_SET) != 0
6493       || bfd_bwrite (location, count, abfd) != count)
6494     return FALSE;
6495
6496   return TRUE;
6497 }
6498
6499 void
6500 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
6501                            arelent *cache_ptr ATTRIBUTE_UNUSED,
6502                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
6503 {
6504   abort ();
6505 }
6506
6507 /* Try to convert a non-ELF reloc into an ELF one.  */
6508
6509 bfd_boolean
6510 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
6511 {
6512   /* Check whether we really have an ELF howto.  */
6513
6514   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6515     {
6516       bfd_reloc_code_real_type code;
6517       reloc_howto_type *howto;
6518
6519       /* Alien reloc: Try to determine its type to replace it with an
6520          equivalent ELF reloc.  */
6521
6522       if (areloc->howto->pc_relative)
6523         {
6524           switch (areloc->howto->bitsize)
6525             {
6526             case 8:
6527               code = BFD_RELOC_8_PCREL;
6528               break;
6529             case 12:
6530               code = BFD_RELOC_12_PCREL;
6531               break;
6532             case 16:
6533               code = BFD_RELOC_16_PCREL;
6534               break;
6535             case 24:
6536               code = BFD_RELOC_24_PCREL;
6537               break;
6538             case 32:
6539               code = BFD_RELOC_32_PCREL;
6540               break;
6541             case 64:
6542               code = BFD_RELOC_64_PCREL;
6543               break;
6544             default:
6545               goto fail;
6546             }
6547
6548           howto = bfd_reloc_type_lookup (abfd, code);
6549
6550           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6551             {
6552               if (howto->pcrel_offset)
6553                 areloc->addend += areloc->address;
6554               else
6555                 areloc->addend -= areloc->address; /* addend is unsigned!! */
6556             }
6557         }
6558       else
6559         {
6560           switch (areloc->howto->bitsize)
6561             {
6562             case 8:
6563               code = BFD_RELOC_8;
6564               break;
6565             case 14:
6566               code = BFD_RELOC_14;
6567               break;
6568             case 16:
6569               code = BFD_RELOC_16;
6570               break;
6571             case 26:
6572               code = BFD_RELOC_26;
6573               break;
6574             case 32:
6575               code = BFD_RELOC_32;
6576               break;
6577             case 64:
6578               code = BFD_RELOC_64;
6579               break;
6580             default:
6581               goto fail;
6582             }
6583
6584           howto = bfd_reloc_type_lookup (abfd, code);
6585         }
6586
6587       if (howto)
6588         areloc->howto = howto;
6589       else
6590         goto fail;
6591     }
6592
6593   return TRUE;
6594
6595  fail:
6596   (*_bfd_error_handler)
6597     (_("%B: unsupported relocation type %s"),
6598      abfd, areloc->howto->name);
6599   bfd_set_error (bfd_error_bad_value);
6600   return FALSE;
6601 }
6602
6603 bfd_boolean
6604 _bfd_elf_close_and_cleanup (bfd *abfd)
6605 {
6606   if (bfd_get_format (abfd) == bfd_object)
6607     {
6608       if (elf_shstrtab (abfd) != NULL)
6609         _bfd_elf_strtab_free (elf_shstrtab (abfd));
6610     }
6611
6612   return _bfd_generic_close_and_cleanup (abfd);
6613 }
6614
6615 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6616    in the relocation's offset.  Thus we cannot allow any sort of sanity
6617    range-checking to interfere.  There is nothing else to do in processing
6618    this reloc.  */
6619
6620 bfd_reloc_status_type
6621 _bfd_elf_rel_vtable_reloc_fn
6622   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
6623    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
6624    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
6625    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
6626 {
6627   return bfd_reloc_ok;
6628 }
6629 \f
6630 /* Elf core file support.  Much of this only works on native
6631    toolchains, since we rely on knowing the
6632    machine-dependent procfs structure in order to pick
6633    out details about the corefile.  */
6634
6635 #ifdef HAVE_SYS_PROCFS_H
6636 # include <sys/procfs.h>
6637 #endif
6638
6639 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
6640
6641 static int
6642 elfcore_make_pid (bfd *abfd)
6643 {
6644   return ((elf_tdata (abfd)->core_lwpid << 16)
6645           + (elf_tdata (abfd)->core_pid));
6646 }
6647
6648 /* If there isn't a section called NAME, make one, using
6649    data from SECT.  Note, this function will generate a
6650    reference to NAME, so you shouldn't deallocate or
6651    overwrite it.  */
6652
6653 static bfd_boolean
6654 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
6655 {
6656   asection *sect2;
6657
6658   if (bfd_get_section_by_name (abfd, name) != NULL)
6659     return TRUE;
6660
6661   sect2 = bfd_make_section (abfd, name);
6662   if (sect2 == NULL)
6663     return FALSE;
6664
6665   sect2->size = sect->size;
6666   sect2->filepos = sect->filepos;
6667   sect2->flags = sect->flags;
6668   sect2->alignment_power = sect->alignment_power;
6669   return TRUE;
6670 }
6671
6672 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
6673    actually creates up to two pseudosections:
6674    - For the single-threaded case, a section named NAME, unless
6675      such a section already exists.
6676    - For the multi-threaded case, a section named "NAME/PID", where
6677      PID is elfcore_make_pid (abfd).
6678    Both pseudosections have identical contents. */
6679 bfd_boolean
6680 _bfd_elfcore_make_pseudosection (bfd *abfd,
6681                                  char *name,
6682                                  size_t size,
6683                                  ufile_ptr filepos)
6684 {
6685   char buf[100];
6686   char *threaded_name;
6687   size_t len;
6688   asection *sect;
6689
6690   /* Build the section name.  */
6691
6692   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
6693   len = strlen (buf) + 1;
6694   threaded_name = bfd_alloc (abfd, len);
6695   if (threaded_name == NULL)
6696     return FALSE;
6697   memcpy (threaded_name, buf, len);
6698
6699   sect = bfd_make_section_anyway (abfd, threaded_name);
6700   if (sect == NULL)
6701     return FALSE;
6702   sect->size = size;
6703   sect->filepos = filepos;
6704   sect->flags = SEC_HAS_CONTENTS;
6705   sect->alignment_power = 2;
6706
6707   return elfcore_maybe_make_sect (abfd, name, sect);
6708 }
6709
6710 /* prstatus_t exists on:
6711      solaris 2.5+
6712      linux 2.[01] + glibc
6713      unixware 4.2
6714 */
6715
6716 #if defined (HAVE_PRSTATUS_T)
6717
6718 static bfd_boolean
6719 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6720 {
6721   size_t size;
6722   int offset;
6723
6724   if (note->descsz == sizeof (prstatus_t))
6725     {
6726       prstatus_t prstat;
6727
6728       size = sizeof (prstat.pr_reg);
6729       offset   = offsetof (prstatus_t, pr_reg);
6730       memcpy (&prstat, note->descdata, sizeof (prstat));
6731
6732       /* Do not overwrite the core signal if it
6733          has already been set by another thread.  */
6734       if (elf_tdata (abfd)->core_signal == 0)
6735         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6736       elf_tdata (abfd)->core_pid = prstat.pr_pid;
6737
6738       /* pr_who exists on:
6739          solaris 2.5+
6740          unixware 4.2
6741          pr_who doesn't exist on:
6742          linux 2.[01]
6743          */
6744 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6745       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6746 #endif
6747     }
6748 #if defined (HAVE_PRSTATUS32_T)
6749   else if (note->descsz == sizeof (prstatus32_t))
6750     {
6751       /* 64-bit host, 32-bit corefile */
6752       prstatus32_t prstat;
6753
6754       size = sizeof (prstat.pr_reg);
6755       offset   = offsetof (prstatus32_t, pr_reg);
6756       memcpy (&prstat, note->descdata, sizeof (prstat));
6757
6758       /* Do not overwrite the core signal if it
6759          has already been set by another thread.  */
6760       if (elf_tdata (abfd)->core_signal == 0)
6761         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6762       elf_tdata (abfd)->core_pid = prstat.pr_pid;
6763
6764       /* pr_who exists on:
6765          solaris 2.5+
6766          unixware 4.2
6767          pr_who doesn't exist on:
6768          linux 2.[01]
6769          */
6770 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6771       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6772 #endif
6773     }
6774 #endif /* HAVE_PRSTATUS32_T */
6775   else
6776     {
6777       /* Fail - we don't know how to handle any other
6778          note size (ie. data object type).  */
6779       return TRUE;
6780     }
6781
6782   /* Make a ".reg/999" section and a ".reg" section.  */
6783   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
6784                                           size, note->descpos + offset);
6785 }
6786 #endif /* defined (HAVE_PRSTATUS_T) */
6787
6788 /* Create a pseudosection containing the exact contents of NOTE.  */
6789 static bfd_boolean
6790 elfcore_make_note_pseudosection (bfd *abfd,
6791                                  char *name,
6792                                  Elf_Internal_Note *note)
6793 {
6794   return _bfd_elfcore_make_pseudosection (abfd, name,
6795                                           note->descsz, note->descpos);
6796 }
6797
6798 /* There isn't a consistent prfpregset_t across platforms,
6799    but it doesn't matter, because we don't have to pick this
6800    data structure apart.  */
6801
6802 static bfd_boolean
6803 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
6804 {
6805   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6806 }
6807
6808 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6809    type of 5 (NT_PRXFPREG).  Just include the whole note's contents
6810    literally.  */
6811
6812 static bfd_boolean
6813 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
6814 {
6815   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
6816 }
6817
6818 #if defined (HAVE_PRPSINFO_T)
6819 typedef prpsinfo_t   elfcore_psinfo_t;
6820 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
6821 typedef prpsinfo32_t elfcore_psinfo32_t;
6822 #endif
6823 #endif
6824
6825 #if defined (HAVE_PSINFO_T)
6826 typedef psinfo_t   elfcore_psinfo_t;
6827 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
6828 typedef psinfo32_t elfcore_psinfo32_t;
6829 #endif
6830 #endif
6831
6832 /* return a malloc'ed copy of a string at START which is at
6833    most MAX bytes long, possibly without a terminating '\0'.
6834    the copy will always have a terminating '\0'.  */
6835
6836 char *
6837 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
6838 {
6839   char *dups;
6840   char *end = memchr (start, '\0', max);
6841   size_t len;
6842
6843   if (end == NULL)
6844     len = max;
6845   else
6846     len = end - start;
6847
6848   dups = bfd_alloc (abfd, len + 1);
6849   if (dups == NULL)
6850     return NULL;
6851
6852   memcpy (dups, start, len);
6853   dups[len] = '\0';
6854
6855   return dups;
6856 }
6857
6858 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6859 static bfd_boolean
6860 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
6861 {
6862   if (note->descsz == sizeof (elfcore_psinfo_t))
6863     {
6864       elfcore_psinfo_t psinfo;
6865
6866       memcpy (&psinfo, note->descdata, sizeof (psinfo));
6867
6868       elf_tdata (abfd)->core_program
6869         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6870                                 sizeof (psinfo.pr_fname));
6871
6872       elf_tdata (abfd)->core_command
6873         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6874                                 sizeof (psinfo.pr_psargs));
6875     }
6876 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6877   else if (note->descsz == sizeof (elfcore_psinfo32_t))
6878     {
6879       /* 64-bit host, 32-bit corefile */
6880       elfcore_psinfo32_t psinfo;
6881
6882       memcpy (&psinfo, note->descdata, sizeof (psinfo));
6883
6884       elf_tdata (abfd)->core_program
6885         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6886                                 sizeof (psinfo.pr_fname));
6887
6888       elf_tdata (abfd)->core_command
6889         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6890                                 sizeof (psinfo.pr_psargs));
6891     }
6892 #endif
6893
6894   else
6895     {
6896       /* Fail - we don't know how to handle any other
6897          note size (ie. data object type).  */
6898       return TRUE;
6899     }
6900
6901   /* Note that for some reason, a spurious space is tacked
6902      onto the end of the args in some (at least one anyway)
6903      implementations, so strip it off if it exists.  */
6904
6905   {
6906     char *command = elf_tdata (abfd)->core_command;
6907     int n = strlen (command);
6908
6909     if (0 < n && command[n - 1] == ' ')
6910       command[n - 1] = '\0';
6911   }
6912
6913   return TRUE;
6914 }
6915 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6916
6917 #if defined (HAVE_PSTATUS_T)
6918 static bfd_boolean
6919 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
6920 {
6921   if (note->descsz == sizeof (pstatus_t)
6922 #if defined (HAVE_PXSTATUS_T)
6923       || note->descsz == sizeof (pxstatus_t)
6924 #endif
6925       )
6926     {
6927       pstatus_t pstat;
6928
6929       memcpy (&pstat, note->descdata, sizeof (pstat));
6930
6931       elf_tdata (abfd)->core_pid = pstat.pr_pid;
6932     }
6933 #if defined (HAVE_PSTATUS32_T)
6934   else if (note->descsz == sizeof (pstatus32_t))
6935     {
6936       /* 64-bit host, 32-bit corefile */
6937       pstatus32_t pstat;
6938
6939       memcpy (&pstat, note->descdata, sizeof (pstat));
6940
6941       elf_tdata (abfd)->core_pid = pstat.pr_pid;
6942     }
6943 #endif
6944   /* Could grab some more details from the "representative"
6945      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6946      NT_LWPSTATUS note, presumably.  */
6947
6948   return TRUE;
6949 }
6950 #endif /* defined (HAVE_PSTATUS_T) */
6951
6952 #if defined (HAVE_LWPSTATUS_T)
6953 static bfd_boolean
6954 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
6955 {
6956   lwpstatus_t lwpstat;
6957   char buf[100];
6958   char *name;
6959   size_t len;
6960   asection *sect;
6961
6962   if (note->descsz != sizeof (lwpstat)
6963 #if defined (HAVE_LWPXSTATUS_T)
6964       && note->descsz != sizeof (lwpxstatus_t)
6965 #endif
6966       )
6967     return TRUE;
6968
6969   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
6970
6971   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
6972   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
6973
6974   /* Make a ".reg/999" section.  */
6975
6976   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
6977   len = strlen (buf) + 1;
6978   name = bfd_alloc (abfd, len);
6979   if (name == NULL)
6980     return FALSE;
6981   memcpy (name, buf, len);
6982
6983   sect = bfd_make_section_anyway (abfd, name);
6984   if (sect == NULL)
6985     return FALSE;
6986
6987 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6988   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
6989   sect->filepos = note->descpos
6990     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
6991 #endif
6992
6993 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6994   sect->size = sizeof (lwpstat.pr_reg);
6995   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
6996 #endif
6997
6998   sect->flags = SEC_HAS_CONTENTS;
6999   sect->alignment_power = 2;
7000
7001   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7002     return FALSE;
7003
7004   /* Make a ".reg2/999" section */
7005
7006   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7007   len = strlen (buf) + 1;
7008   name = bfd_alloc (abfd, len);
7009   if (name == NULL)
7010     return FALSE;
7011   memcpy (name, buf, len);
7012
7013   sect = bfd_make_section_anyway (abfd, name);
7014   if (sect == NULL)
7015     return FALSE;
7016
7017 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7018   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7019   sect->filepos = note->descpos
7020     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7021 #endif
7022
7023 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7024   sect->size = sizeof (lwpstat.pr_fpreg);
7025   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7026 #endif
7027
7028   sect->flags = SEC_HAS_CONTENTS;
7029   sect->alignment_power = 2;
7030
7031   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7032 }
7033 #endif /* defined (HAVE_LWPSTATUS_T) */
7034
7035 #if defined (HAVE_WIN32_PSTATUS_T)
7036 static bfd_boolean
7037 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7038 {
7039   char buf[30];
7040   char *name;
7041   size_t len;
7042   asection *sect;
7043   win32_pstatus_t pstatus;
7044
7045   if (note->descsz < sizeof (pstatus))
7046     return TRUE;
7047
7048   memcpy (&pstatus, note->descdata, sizeof (pstatus));
7049
7050   switch (pstatus.data_type)
7051     {
7052     case NOTE_INFO_PROCESS:
7053       /* FIXME: need to add ->core_command.  */
7054       elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7055       elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
7056       break;
7057
7058     case NOTE_INFO_THREAD:
7059       /* Make a ".reg/999" section.  */
7060       sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
7061
7062       len = strlen (buf) + 1;
7063       name = bfd_alloc (abfd, len);
7064       if (name == NULL)
7065         return FALSE;
7066
7067       memcpy (name, buf, len);
7068
7069       sect = bfd_make_section_anyway (abfd, name);
7070       if (sect == NULL)
7071         return FALSE;
7072
7073       sect->size = sizeof (pstatus.data.thread_info.thread_context);
7074       sect->filepos = (note->descpos
7075                        + offsetof (struct win32_pstatus,
7076                                    data.thread_info.thread_context));
7077       sect->flags = SEC_HAS_CONTENTS;
7078       sect->alignment_power = 2;
7079
7080       if (pstatus.data.thread_info.is_active_thread)
7081         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7082           return FALSE;
7083       break;
7084
7085     case NOTE_INFO_MODULE:
7086       /* Make a ".module/xxxxxxxx" section.  */
7087       sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
7088
7089       len = strlen (buf) + 1;
7090       name = bfd_alloc (abfd, len);
7091       if (name == NULL)
7092         return FALSE;
7093
7094       memcpy (name, buf, len);
7095
7096       sect = bfd_make_section_anyway (abfd, name);
7097
7098       if (sect == NULL)
7099         return FALSE;
7100
7101       sect->size = note->descsz;
7102       sect->filepos = note->descpos;
7103       sect->flags = SEC_HAS_CONTENTS;
7104       sect->alignment_power = 2;
7105       break;
7106
7107     default:
7108       return TRUE;
7109     }
7110
7111   return TRUE;
7112 }
7113 #endif /* HAVE_WIN32_PSTATUS_T */
7114
7115 static bfd_boolean
7116 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7117 {
7118   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7119
7120   switch (note->type)
7121     {
7122     default:
7123       return TRUE;
7124
7125     case NT_PRSTATUS:
7126       if (bed->elf_backend_grok_prstatus)
7127         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7128           return TRUE;
7129 #if defined (HAVE_PRSTATUS_T)
7130       return elfcore_grok_prstatus (abfd, note);
7131 #else
7132       return TRUE;
7133 #endif
7134
7135 #if defined (HAVE_PSTATUS_T)
7136     case NT_PSTATUS:
7137       return elfcore_grok_pstatus (abfd, note);
7138 #endif
7139
7140 #if defined (HAVE_LWPSTATUS_T)
7141     case NT_LWPSTATUS:
7142       return elfcore_grok_lwpstatus (abfd, note);
7143 #endif
7144
7145     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
7146       return elfcore_grok_prfpreg (abfd, note);
7147
7148 #if defined (HAVE_WIN32_PSTATUS_T)
7149     case NT_WIN32PSTATUS:
7150       return elfcore_grok_win32pstatus (abfd, note);
7151 #endif
7152
7153     case NT_PRXFPREG:           /* Linux SSE extension */
7154       if (note->namesz == 6
7155           && strcmp (note->namedata, "LINUX") == 0)
7156         return elfcore_grok_prxfpreg (abfd, note);
7157       else
7158         return TRUE;
7159
7160     case NT_PRPSINFO:
7161     case NT_PSINFO:
7162       if (bed->elf_backend_grok_psinfo)
7163         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7164           return TRUE;
7165 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7166       return elfcore_grok_psinfo (abfd, note);
7167 #else
7168       return TRUE;
7169 #endif
7170
7171     case NT_AUXV:
7172       {
7173         asection *sect = bfd_make_section_anyway (abfd, ".auxv");
7174
7175         if (sect == NULL)
7176           return FALSE;
7177         sect->size = note->descsz;
7178         sect->filepos = note->descpos;
7179         sect->flags = SEC_HAS_CONTENTS;
7180         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7181
7182         return TRUE;
7183       }
7184     }
7185 }
7186
7187 static bfd_boolean
7188 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7189 {
7190   char *cp;
7191
7192   cp = strchr (note->namedata, '@');
7193   if (cp != NULL)
7194     {
7195       *lwpidp = atoi(cp + 1);
7196       return TRUE;
7197     }
7198   return FALSE;
7199 }
7200
7201 static bfd_boolean
7202 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
7203 {
7204
7205   /* Signal number at offset 0x08. */
7206   elf_tdata (abfd)->core_signal
7207     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7208
7209   /* Process ID at offset 0x50. */
7210   elf_tdata (abfd)->core_pid
7211     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7212
7213   /* Command name at 0x7c (max 32 bytes, including nul). */
7214   elf_tdata (abfd)->core_command
7215     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7216
7217   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7218                                           note);
7219 }
7220
7221 static bfd_boolean
7222 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
7223 {
7224   int lwp;
7225
7226   if (elfcore_netbsd_get_lwpid (note, &lwp))
7227     elf_tdata (abfd)->core_lwpid = lwp;
7228
7229   if (note->type == NT_NETBSDCORE_PROCINFO)
7230     {
7231       /* NetBSD-specific core "procinfo".  Note that we expect to
7232          find this note before any of the others, which is fine,
7233          since the kernel writes this note out first when it
7234          creates a core file.  */
7235
7236       return elfcore_grok_netbsd_procinfo (abfd, note);
7237     }
7238
7239   /* As of Jan 2002 there are no other machine-independent notes
7240      defined for NetBSD core files.  If the note type is less
7241      than the start of the machine-dependent note types, we don't
7242      understand it.  */
7243
7244   if (note->type < NT_NETBSDCORE_FIRSTMACH)
7245     return TRUE;
7246
7247
7248   switch (bfd_get_arch (abfd))
7249     {
7250     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7251        PT_GETFPREGS == mach+2.  */
7252
7253     case bfd_arch_alpha:
7254     case bfd_arch_sparc:
7255       switch (note->type)
7256         {
7257         case NT_NETBSDCORE_FIRSTMACH+0:
7258           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7259
7260         case NT_NETBSDCORE_FIRSTMACH+2:
7261           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7262
7263         default:
7264           return TRUE;
7265         }
7266
7267     /* On all other arch's, PT_GETREGS == mach+1 and
7268        PT_GETFPREGS == mach+3.  */
7269
7270     default:
7271       switch (note->type)
7272         {
7273         case NT_NETBSDCORE_FIRSTMACH+1:
7274           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7275
7276         case NT_NETBSDCORE_FIRSTMACH+3:
7277           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7278
7279         default:
7280           return TRUE;
7281         }
7282     }
7283     /* NOTREACHED */
7284 }
7285
7286 static bfd_boolean
7287 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
7288 {
7289   void *ddata = note->descdata;
7290   char buf[100];
7291   char *name;
7292   asection *sect;
7293   short sig;
7294   unsigned flags;
7295
7296   /* nto_procfs_status 'pid' field is at offset 0.  */
7297   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
7298
7299   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
7300   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
7301
7302   /* nto_procfs_status 'flags' field is at offset 8.  */
7303   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
7304
7305   /* nto_procfs_status 'what' field is at offset 14.  */
7306   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
7307     {
7308       elf_tdata (abfd)->core_signal = sig;
7309       elf_tdata (abfd)->core_lwpid = *tid;
7310     }
7311
7312   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
7313      do not come from signals so we make sure we set the current
7314      thread just in case.  */
7315   if (flags & 0x00000080)
7316     elf_tdata (abfd)->core_lwpid = *tid;
7317
7318   /* Make a ".qnx_core_status/%d" section.  */
7319   sprintf (buf, ".qnx_core_status/%d", *tid);
7320
7321   name = bfd_alloc (abfd, strlen (buf) + 1);
7322   if (name == NULL)
7323     return FALSE;
7324   strcpy (name, buf);
7325
7326   sect = bfd_make_section_anyway (abfd, name);
7327   if (sect == NULL)
7328     return FALSE;
7329
7330   sect->size            = note->descsz;
7331   sect->filepos         = note->descpos;
7332   sect->flags           = SEC_HAS_CONTENTS;
7333   sect->alignment_power = 2;
7334
7335   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
7336 }
7337
7338 static bfd_boolean
7339 elfcore_grok_nto_gregs (bfd *abfd, Elf_Internal_Note *note, pid_t tid)
7340 {
7341   char buf[100];
7342   char *name;
7343   asection *sect;
7344
7345   /* Make a ".reg/%d" section.  */
7346   sprintf (buf, ".reg/%d", tid);
7347
7348   name = bfd_alloc (abfd, strlen (buf) + 1);
7349   if (name == NULL)
7350     return FALSE;
7351   strcpy (name, buf);
7352
7353   sect = bfd_make_section_anyway (abfd, name);
7354   if (sect == NULL)
7355     return FALSE;
7356
7357   sect->size            = note->descsz;
7358   sect->filepos         = note->descpos;
7359   sect->flags           = SEC_HAS_CONTENTS;
7360   sect->alignment_power = 2;
7361
7362   /* This is the current thread.  */
7363   if (elf_tdata (abfd)->core_lwpid == tid)
7364     return elfcore_maybe_make_sect (abfd, ".reg", sect);
7365
7366   return TRUE;
7367 }
7368
7369 #define BFD_QNT_CORE_INFO       7
7370 #define BFD_QNT_CORE_STATUS     8
7371 #define BFD_QNT_CORE_GREG       9
7372 #define BFD_QNT_CORE_FPREG      10
7373
7374 static bfd_boolean
7375 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
7376 {
7377   /* Every GREG section has a STATUS section before it.  Store the
7378      tid from the previous call to pass down to the next gregs
7379      function.  */
7380   static pid_t tid = 1;
7381
7382   switch (note->type)
7383     {
7384     case BFD_QNT_CORE_INFO:   return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7385     case BFD_QNT_CORE_STATUS: return elfcore_grok_nto_status (abfd, note, &tid);
7386     case BFD_QNT_CORE_GREG:   return elfcore_grok_nto_gregs (abfd, note, tid);
7387     case BFD_QNT_CORE_FPREG:  return elfcore_grok_prfpreg (abfd, note);
7388     default:                  return TRUE;
7389     }
7390 }
7391
7392 /* Function: elfcore_write_note
7393
7394    Inputs:
7395      buffer to hold note
7396      name of note
7397      type of note
7398      data for note
7399      size of data for note
7400
7401    Return:
7402    End of buffer containing note.  */
7403
7404 char *
7405 elfcore_write_note (bfd  *abfd,
7406                     char *buf,
7407                     int  *bufsiz,
7408                     const char *name,
7409                     int  type,
7410                     const void *input,
7411                     int  size)
7412 {
7413   Elf_External_Note *xnp;
7414   size_t namesz;
7415   size_t pad;
7416   size_t newspace;
7417   char *p, *dest;
7418
7419   namesz = 0;
7420   pad = 0;
7421   if (name != NULL)
7422     {
7423       const struct elf_backend_data *bed;
7424
7425       namesz = strlen (name) + 1;
7426       bed = get_elf_backend_data (abfd);
7427       pad = -namesz & ((1 << bed->s->log_file_align) - 1);
7428     }
7429
7430   newspace = 12 + namesz + pad + size;
7431
7432   p = realloc (buf, *bufsiz + newspace);
7433   dest = p + *bufsiz;
7434   *bufsiz += newspace;
7435   xnp = (Elf_External_Note *) dest;
7436   H_PUT_32 (abfd, namesz, xnp->namesz);
7437   H_PUT_32 (abfd, size, xnp->descsz);
7438   H_PUT_32 (abfd, type, xnp->type);
7439   dest = xnp->name;
7440   if (name != NULL)
7441     {
7442       memcpy (dest, name, namesz);
7443       dest += namesz;
7444       while (pad != 0)
7445         {
7446           *dest++ = '\0';
7447           --pad;
7448         }
7449     }
7450   memcpy (dest, input, size);
7451   return p;
7452 }
7453
7454 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7455 char *
7456 elfcore_write_prpsinfo (bfd  *abfd,
7457                         char *buf,
7458                         int  *bufsiz,
7459                         const char *fname,
7460                         const char *psargs)
7461 {
7462   int note_type;
7463   char *note_name = "CORE";
7464
7465 #if defined (HAVE_PSINFO_T)
7466   psinfo_t  data;
7467   note_type = NT_PSINFO;
7468 #else
7469   prpsinfo_t data;
7470   note_type = NT_PRPSINFO;
7471 #endif
7472
7473   memset (&data, 0, sizeof (data));
7474   strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7475   strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7476   return elfcore_write_note (abfd, buf, bufsiz,
7477                              note_name, note_type, &data, sizeof (data));
7478 }
7479 #endif  /* PSINFO_T or PRPSINFO_T */
7480
7481 #if defined (HAVE_PRSTATUS_T)
7482 char *
7483 elfcore_write_prstatus (bfd *abfd,
7484                         char *buf,
7485                         int *bufsiz,
7486                         long pid,
7487                         int cursig,
7488                         const void *gregs)
7489 {
7490   prstatus_t prstat;
7491   char *note_name = "CORE";
7492
7493   memset (&prstat, 0, sizeof (prstat));
7494   prstat.pr_pid = pid;
7495   prstat.pr_cursig = cursig;
7496   memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7497   return elfcore_write_note (abfd, buf, bufsiz,
7498                              note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7499 }
7500 #endif /* HAVE_PRSTATUS_T */
7501
7502 #if defined (HAVE_LWPSTATUS_T)
7503 char *
7504 elfcore_write_lwpstatus (bfd *abfd,
7505                          char *buf,
7506                          int *bufsiz,
7507                          long pid,
7508                          int cursig,
7509                          const void *gregs)
7510 {
7511   lwpstatus_t lwpstat;
7512   char *note_name = "CORE";
7513
7514   memset (&lwpstat, 0, sizeof (lwpstat));
7515   lwpstat.pr_lwpid  = pid >> 16;
7516   lwpstat.pr_cursig = cursig;
7517 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7518   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7519 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7520 #if !defined(gregs)
7521   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7522           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7523 #else
7524   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7525           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7526 #endif
7527 #endif
7528   return elfcore_write_note (abfd, buf, bufsiz, note_name,
7529                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7530 }
7531 #endif /* HAVE_LWPSTATUS_T */
7532
7533 #if defined (HAVE_PSTATUS_T)
7534 char *
7535 elfcore_write_pstatus (bfd *abfd,
7536                        char *buf,
7537                        int *bufsiz,
7538                        long pid,
7539                        int cursig,
7540                        const void *gregs)
7541 {
7542   pstatus_t pstat;
7543   char *note_name = "CORE";
7544
7545   memset (&pstat, 0, sizeof (pstat));
7546   pstat.pr_pid = pid & 0xffff;
7547   buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
7548                             NT_PSTATUS, &pstat, sizeof (pstat));
7549   return buf;
7550 }
7551 #endif /* HAVE_PSTATUS_T */
7552
7553 char *
7554 elfcore_write_prfpreg (bfd *abfd,
7555                        char *buf,
7556                        int *bufsiz,
7557                        const void *fpregs,
7558                        int size)
7559 {
7560   char *note_name = "CORE";
7561   return elfcore_write_note (abfd, buf, bufsiz,
7562                              note_name, NT_FPREGSET, fpregs, size);
7563 }
7564
7565 char *
7566 elfcore_write_prxfpreg (bfd *abfd,
7567                         char *buf,
7568                         int *bufsiz,
7569                         const void *xfpregs,
7570                         int size)
7571 {
7572   char *note_name = "LINUX";
7573   return elfcore_write_note (abfd, buf, bufsiz,
7574                              note_name, NT_PRXFPREG, xfpregs, size);
7575 }
7576
7577 static bfd_boolean
7578 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
7579 {
7580   char *buf;
7581   char *p;
7582
7583   if (size <= 0)
7584     return TRUE;
7585
7586   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
7587     return FALSE;
7588
7589   buf = bfd_malloc (size);
7590   if (buf == NULL)
7591     return FALSE;
7592
7593   if (bfd_bread (buf, size, abfd) != size)
7594     {
7595     error:
7596       free (buf);
7597       return FALSE;
7598     }
7599
7600   p = buf;
7601   while (p < buf + size)
7602     {
7603       /* FIXME: bad alignment assumption.  */
7604       Elf_External_Note *xnp = (Elf_External_Note *) p;
7605       Elf_Internal_Note in;
7606
7607       in.type = H_GET_32 (abfd, xnp->type);
7608
7609       in.namesz = H_GET_32 (abfd, xnp->namesz);
7610       in.namedata = xnp->name;
7611
7612       in.descsz = H_GET_32 (abfd, xnp->descsz);
7613       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7614       in.descpos = offset + (in.descdata - buf);
7615
7616       if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7617         {
7618           if (! elfcore_grok_netbsd_note (abfd, &in))
7619             goto error;
7620         }
7621       else if (strncmp (in.namedata, "QNX", 3) == 0)
7622         {
7623           if (! elfcore_grok_nto_note (abfd, &in))
7624             goto error;
7625         }
7626       else
7627         {
7628           if (! elfcore_grok_note (abfd, &in))
7629             goto error;
7630         }
7631
7632       p = in.descdata + BFD_ALIGN (in.descsz, 4);
7633     }
7634
7635   free (buf);
7636   return TRUE;
7637 }
7638 \f
7639 /* Providing external access to the ELF program header table.  */
7640
7641 /* Return an upper bound on the number of bytes required to store a
7642    copy of ABFD's program header table entries.  Return -1 if an error
7643    occurs; bfd_get_error will return an appropriate code.  */
7644
7645 long
7646 bfd_get_elf_phdr_upper_bound (bfd *abfd)
7647 {
7648   if (abfd->xvec->flavour != bfd_target_elf_flavour)
7649     {
7650       bfd_set_error (bfd_error_wrong_format);
7651       return -1;
7652     }
7653
7654   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
7655 }
7656
7657 /* Copy ABFD's program header table entries to *PHDRS.  The entries
7658    will be stored as an array of Elf_Internal_Phdr structures, as
7659    defined in include/elf/internal.h.  To find out how large the
7660    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7661
7662    Return the number of program header table entries read, or -1 if an
7663    error occurs; bfd_get_error will return an appropriate code.  */
7664
7665 int
7666 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
7667 {
7668   int num_phdrs;
7669
7670   if (abfd->xvec->flavour != bfd_target_elf_flavour)
7671     {
7672       bfd_set_error (bfd_error_wrong_format);
7673       return -1;
7674     }
7675
7676   num_phdrs = elf_elfheader (abfd)->e_phnum;
7677   memcpy (phdrs, elf_tdata (abfd)->phdr,
7678           num_phdrs * sizeof (Elf_Internal_Phdr));
7679
7680   return num_phdrs;
7681 }
7682
7683 void
7684 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
7685 {
7686 #ifdef BFD64
7687   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
7688
7689   i_ehdrp = elf_elfheader (abfd);
7690   if (i_ehdrp == NULL)
7691     sprintf_vma (buf, value);
7692   else
7693     {
7694       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7695         {
7696 #if BFD_HOST_64BIT_LONG
7697           sprintf (buf, "%016lx", value);
7698 #else
7699           sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
7700                    _bfd_int64_low (value));
7701 #endif
7702         }
7703       else
7704         sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
7705     }
7706 #else
7707   sprintf_vma (buf, value);
7708 #endif
7709 }
7710
7711 void
7712 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
7713 {
7714 #ifdef BFD64
7715   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
7716
7717   i_ehdrp = elf_elfheader (abfd);
7718   if (i_ehdrp == NULL)
7719     fprintf_vma ((FILE *) stream, value);
7720   else
7721     {
7722       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7723         {
7724 #if BFD_HOST_64BIT_LONG
7725           fprintf ((FILE *) stream, "%016lx", value);
7726 #else
7727           fprintf ((FILE *) stream, "%08lx%08lx",
7728                    _bfd_int64_high (value), _bfd_int64_low (value));
7729 #endif
7730         }
7731       else
7732         fprintf ((FILE *) stream, "%08lx",
7733                  (unsigned long) (value & 0xffffffff));
7734     }
7735 #else
7736   fprintf_vma ((FILE *) stream, value);
7737 #endif
7738 }
7739
7740 enum elf_reloc_type_class
7741 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
7742 {
7743   return reloc_class_normal;
7744 }
7745
7746 /* For RELA architectures, return the relocation value for a
7747    relocation against a local symbol.  */
7748
7749 bfd_vma
7750 _bfd_elf_rela_local_sym (bfd *abfd,
7751                          Elf_Internal_Sym *sym,
7752                          asection **psec,
7753                          Elf_Internal_Rela *rel)
7754 {
7755   asection *sec = *psec;
7756   bfd_vma relocation;
7757
7758   relocation = (sec->output_section->vma
7759                 + sec->output_offset
7760                 + sym->st_value);
7761   if ((sec->flags & SEC_MERGE)
7762       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
7763       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
7764     {
7765       rel->r_addend =
7766         _bfd_merged_section_offset (abfd, psec,
7767                                     elf_section_data (sec)->sec_info,
7768                                     sym->st_value + rel->r_addend);
7769       if (sec != *psec)
7770         {
7771           /* If we have changed the section, and our original section is
7772              marked with SEC_EXCLUDE, it means that the original
7773              SEC_MERGE section has been completely subsumed in some
7774              other SEC_MERGE section.  In this case, we need to leave
7775              some info around for --emit-relocs.  */
7776           if ((sec->flags & SEC_EXCLUDE) != 0)
7777             sec->kept_section = *psec;
7778           sec = *psec;
7779         }
7780       rel->r_addend -= relocation;
7781       rel->r_addend += sec->output_section->vma + sec->output_offset;
7782     }
7783   return relocation;
7784 }
7785
7786 bfd_vma
7787 _bfd_elf_rel_local_sym (bfd *abfd,
7788                         Elf_Internal_Sym *sym,
7789                         asection **psec,
7790                         bfd_vma addend)
7791 {
7792   asection *sec = *psec;
7793
7794   if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
7795     return sym->st_value + addend;
7796
7797   return _bfd_merged_section_offset (abfd, psec,
7798                                      elf_section_data (sec)->sec_info,
7799                                      sym->st_value + addend);
7800 }
7801
7802 bfd_vma
7803 _bfd_elf_section_offset (bfd *abfd,
7804                          struct bfd_link_info *info,
7805                          asection *sec,
7806                          bfd_vma offset)
7807 {
7808   switch (sec->sec_info_type)
7809     {
7810     case ELF_INFO_TYPE_STABS:
7811       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
7812                                        offset);
7813     case ELF_INFO_TYPE_EH_FRAME:
7814       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
7815     default:
7816       return offset;
7817     }
7818 }
7819 \f
7820 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
7821    reconstruct an ELF file by reading the segments out of remote memory
7822    based on the ELF file header at EHDR_VMA and the ELF program headers it
7823    points to.  If not null, *LOADBASEP is filled in with the difference
7824    between the VMAs from which the segments were read, and the VMAs the
7825    file headers (and hence BFD's idea of each section's VMA) put them at.
7826
7827    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
7828    remote memory at target address VMA into the local buffer at MYADDR; it
7829    should return zero on success or an `errno' code on failure.  TEMPL must
7830    be a BFD for an ELF target with the word size and byte order found in
7831    the remote memory.  */
7832
7833 bfd *
7834 bfd_elf_bfd_from_remote_memory
7835   (bfd *templ,
7836    bfd_vma ehdr_vma,
7837    bfd_vma *loadbasep,
7838    int (*target_read_memory) (bfd_vma, char *, int))
7839 {
7840   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
7841     (templ, ehdr_vma, loadbasep, target_read_memory);
7842 }
7843 \f
7844 long
7845 _bfd_elf_get_synthetic_symtab (bfd *abfd,
7846                                long symcount ATTRIBUTE_UNUSED,
7847                                asymbol **syms ATTRIBUTE_UNUSED,
7848                                long dynsymcount ATTRIBUTE_UNUSED,
7849                                asymbol **dynsyms,
7850                                asymbol **ret)
7851 {
7852   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7853   asection *relplt;
7854   asymbol *s;
7855   const char *relplt_name;
7856   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
7857   arelent *p;
7858   long count, i, n;
7859   size_t size;
7860   Elf_Internal_Shdr *hdr;
7861   char *names;
7862   asection *plt;
7863
7864   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
7865     return 0;
7866
7867   *ret = NULL;
7868   if (!bed->plt_sym_val)
7869     return 0;
7870
7871   relplt_name = bed->relplt_name;
7872   if (relplt_name == NULL)
7873     relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
7874   relplt = bfd_get_section_by_name (abfd, relplt_name);
7875   if (relplt == NULL)
7876     return 0;
7877
7878   hdr = &elf_section_data (relplt)->this_hdr;
7879   if (hdr->sh_link != elf_dynsymtab (abfd)
7880       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
7881     return 0;
7882
7883   plt = bfd_get_section_by_name (abfd, ".plt");
7884   if (plt == NULL)
7885     return 0;
7886
7887   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
7888   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
7889     return -1;
7890
7891   count = relplt->size / hdr->sh_entsize;
7892   size = count * sizeof (asymbol);
7893   p = relplt->relocation;
7894   for (i = 0; i < count; i++, s++, p++)
7895     size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
7896
7897   s = *ret = bfd_malloc (size);
7898   if (s == NULL)
7899     return -1;
7900
7901   names = (char *) (s + count);
7902   p = relplt->relocation;
7903   n = 0;
7904   for (i = 0; i < count; i++, s++, p++)
7905     {
7906       size_t len;
7907       bfd_vma addr;
7908
7909       addr = bed->plt_sym_val (i, plt, p);
7910       if (addr == (bfd_vma) -1)
7911         continue;
7912
7913       *s = **p->sym_ptr_ptr;
7914       s->section = plt;
7915       s->value = addr - plt->vma;
7916       s->name = names;
7917       len = strlen ((*p->sym_ptr_ptr)->name);
7918       memcpy (names, (*p->sym_ptr_ptr)->name, len);
7919       names += len;
7920       memcpy (names, "@plt", sizeof ("@plt"));
7921       names += sizeof ("@plt");
7922       ++n;
7923     }
7924
7925   return n;
7926 }
7927
7928 /* Sort symbol by binding and section. We want to put definitions
7929    sorted by section at the beginning.  */
7930
7931 static int
7932 elf_sort_elf_symbol (const void *arg1, const void *arg2)
7933 {
7934   const Elf_Internal_Sym *s1;
7935   const Elf_Internal_Sym *s2;
7936   int shndx;
7937
7938   /* Make sure that undefined symbols are at the end.  */
7939   s1 = (const Elf_Internal_Sym *) arg1;
7940   if (s1->st_shndx == SHN_UNDEF)
7941     return 1;
7942   s2 = (const Elf_Internal_Sym *) arg2;
7943   if (s2->st_shndx == SHN_UNDEF)
7944     return -1;
7945
7946   /* Sorted by section index.  */
7947   shndx = s1->st_shndx - s2->st_shndx;
7948   if (shndx != 0)
7949     return shndx;
7950
7951   /* Sorted by binding.  */
7952   return ELF_ST_BIND (s1->st_info)  - ELF_ST_BIND (s2->st_info);
7953 }
7954
7955 struct elf_symbol
7956 {
7957   Elf_Internal_Sym *sym;
7958   const char *name;
7959 };
7960
7961 static int
7962 elf_sym_name_compare (const void *arg1, const void *arg2)
7963 {
7964   const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7965   const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7966   return strcmp (s1->name, s2->name);
7967 }
7968
7969 /* Check if 2 sections define the same set of local and global
7970    symbols.  */
7971
7972 bfd_boolean
7973 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2)
7974 {
7975   bfd *bfd1, *bfd2;
7976   const struct elf_backend_data *bed1, *bed2;
7977   Elf_Internal_Shdr *hdr1, *hdr2;
7978   bfd_size_type symcount1, symcount2;
7979   Elf_Internal_Sym *isymbuf1, *isymbuf2;
7980   Elf_Internal_Sym *isymstart1 = NULL, *isymstart2 = NULL, *isym;
7981   Elf_Internal_Sym *isymend;
7982   struct elf_symbol *symp, *symtable1 = NULL, *symtable2 = NULL;
7983   bfd_size_type count1, count2, i;
7984   int shndx1, shndx2;
7985   bfd_boolean result;
7986
7987   bfd1 = sec1->owner;
7988   bfd2 = sec2->owner;
7989
7990   /* If both are .gnu.linkonce sections, they have to have the same
7991      section name.  */
7992   if (strncmp (sec1->name, ".gnu.linkonce",
7993                sizeof ".gnu.linkonce" - 1) == 0
7994       && strncmp (sec2->name, ".gnu.linkonce",
7995                   sizeof ".gnu.linkonce" - 1) == 0)
7996     return strcmp (sec1->name + sizeof ".gnu.linkonce",
7997                    sec2->name + sizeof ".gnu.linkonce") == 0;
7998
7999   /* Both sections have to be in ELF.  */
8000   if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
8001       || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
8002     return FALSE;
8003
8004   if (elf_section_type (sec1) != elf_section_type (sec2))
8005     return FALSE;
8006
8007   if ((elf_section_flags (sec1) & SHF_GROUP) != 0
8008       && (elf_section_flags (sec2) & SHF_GROUP) != 0)
8009     {
8010       /* If both are members of section groups, they have to have the
8011          same group name.  */
8012       if (strcmp (elf_group_name (sec1), elf_group_name (sec2)) != 0)
8013         return FALSE;
8014     }
8015
8016   shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
8017   shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
8018   if (shndx1 == -1 || shndx2 == -1)
8019     return FALSE;
8020
8021   bed1 = get_elf_backend_data (bfd1);
8022   bed2 = get_elf_backend_data (bfd2);
8023   hdr1 = &elf_tdata (bfd1)->symtab_hdr;
8024   symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
8025   hdr2 = &elf_tdata (bfd2)->symtab_hdr;
8026   symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
8027
8028   if (symcount1 == 0 || symcount2 == 0)
8029     return FALSE;
8030
8031   isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
8032                                    NULL, NULL, NULL);
8033   isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
8034                                    NULL, NULL, NULL);
8035
8036   result = FALSE;
8037   if (isymbuf1 == NULL || isymbuf2 == NULL)
8038     goto done;
8039
8040   /* Sort symbols by binding and section. Global definitions are at
8041      the beginning.  */
8042   qsort (isymbuf1, symcount1, sizeof (Elf_Internal_Sym),
8043          elf_sort_elf_symbol);
8044   qsort (isymbuf2, symcount2, sizeof (Elf_Internal_Sym),
8045          elf_sort_elf_symbol);
8046
8047   /* Count definitions in the section.  */
8048   count1 = 0;
8049   for (isym = isymbuf1, isymend = isym + symcount1;
8050        isym < isymend; isym++)
8051     {
8052       if (isym->st_shndx == (unsigned int) shndx1)
8053         {
8054           if (count1 == 0)
8055             isymstart1 = isym;
8056           count1++;
8057         }
8058
8059       if (count1 && isym->st_shndx != (unsigned int) shndx1)
8060         break;
8061     }
8062
8063   count2 = 0;
8064   for (isym = isymbuf2, isymend = isym + symcount2;
8065        isym < isymend; isym++)
8066     {
8067       if (isym->st_shndx == (unsigned int) shndx2)
8068         {
8069           if (count2 == 0)
8070             isymstart2 = isym;
8071           count2++;
8072         }
8073
8074       if (count2 && isym->st_shndx != (unsigned int) shndx2)
8075         break;
8076     }
8077
8078   if (count1 == 0 || count2 == 0 || count1 != count2)
8079     goto done;
8080
8081   symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8082   symtable2 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8083
8084   if (symtable1 == NULL || symtable2 == NULL)
8085     goto done;
8086
8087   symp = symtable1;
8088   for (isym = isymstart1, isymend = isym + count1;
8089        isym < isymend; isym++)
8090     {
8091       symp->sym = isym;
8092       symp->name = bfd_elf_string_from_elf_section (bfd1,
8093                                                     hdr1->sh_link,
8094                                                     isym->st_name);
8095       symp++;
8096     }
8097
8098   symp = symtable2;
8099   for (isym = isymstart2, isymend = isym + count1;
8100        isym < isymend; isym++)
8101     {
8102       symp->sym = isym;
8103       symp->name = bfd_elf_string_from_elf_section (bfd2,
8104                                                     hdr2->sh_link,
8105                                                     isym->st_name);
8106       symp++;
8107     }
8108
8109   /* Sort symbol by name.  */
8110   qsort (symtable1, count1, sizeof (struct elf_symbol),
8111          elf_sym_name_compare);
8112   qsort (symtable2, count1, sizeof (struct elf_symbol),
8113          elf_sym_name_compare);
8114
8115   for (i = 0; i < count1; i++)
8116     /* Two symbols must have the same binding, type and name.  */
8117     if (symtable1 [i].sym->st_info != symtable2 [i].sym->st_info
8118         || symtable1 [i].sym->st_other != symtable2 [i].sym->st_other
8119         || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
8120       goto done;
8121
8122   result = TRUE;
8123
8124 done:
8125   if (symtable1)
8126     free (symtable1);
8127   if (symtable2)
8128     free (symtable2);
8129   if (isymbuf1)
8130     free (isymbuf1);
8131   if (isymbuf2)
8132     free (isymbuf2);
8133
8134   return result;
8135 }