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