bfd/elf.c

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