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