bfd/elf.c

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