bfd/elf.c

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