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 (info->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 && info->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 (align > p->p_align
4392                   && !m->p_align_valid
4393                   && (p->p_type != PT_LOAD
4394                       || (abfd->flags & D_PAGED) == 0))
4395                 p->p_align = align;
4396             }
4397
4398           if (!m->p_flags_valid)
4399             {
4400               p->p_flags |= PF_R;
4401               if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4402                 p->p_flags |= PF_X;
4403               if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4404                 p->p_flags |= PF_W;
4405             }
4406         }
4407       off -= off_adjust;
4408
4409       /* Check that all sections are in a PT_LOAD segment.
4410          Don't check funky gdb generated core files.  */
4411       if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4412         for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4413           {
4414             Elf_Internal_Shdr *this_hdr;
4415             asection *sec;
4416
4417             sec = *secpp;
4418             this_hdr = &(elf_section_data(sec)->this_hdr);
4419             if (this_hdr->sh_size != 0
4420                 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, p))
4421               {
4422                 (*_bfd_error_handler)
4423                   (_("%B: section `%A' can't be allocated in segment %d"),
4424                    abfd, sec, j);
4425                 print_segment_map (m);
4426                 bfd_set_error (bfd_error_bad_value);
4427                 return FALSE;
4428               }
4429           }
4430     }
4431
4432   elf_tdata (abfd)->next_file_pos = off;
4433   return TRUE;
4434 }
4435
4436 /* Assign file positions for the other sections.  */
4437
4438 static bfd_boolean
4439 assign_file_positions_for_non_load_sections (bfd *abfd,
4440                                              struct bfd_link_info *link_info)
4441 {
4442   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4443   Elf_Internal_Shdr **i_shdrpp;
4444   Elf_Internal_Shdr **hdrpp;
4445   Elf_Internal_Phdr *phdrs;
4446   Elf_Internal_Phdr *p;
4447   struct elf_segment_map *m;
4448   bfd_vma filehdr_vaddr, filehdr_paddr;
4449   bfd_vma phdrs_vaddr, phdrs_paddr;
4450   file_ptr off;
4451   unsigned int num_sec;
4452   unsigned int i;
4453   unsigned int count;
4454
4455   i_shdrpp = elf_elfsections (abfd);
4456   num_sec = elf_numsections (abfd);
4457   off = elf_tdata (abfd)->next_file_pos;
4458   for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4459     {
4460       struct elf_obj_tdata *tdata = elf_tdata (abfd);
4461       Elf_Internal_Shdr *hdr;
4462
4463       hdr = *hdrpp;
4464       if (hdr->bfd_section != NULL
4465           && (hdr->bfd_section->filepos != 0
4466               || (hdr->sh_type == SHT_NOBITS
4467                   && hdr->contents == NULL)))
4468         BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4469       else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4470         {
4471           if (hdr->sh_size != 0)
4472             ((*_bfd_error_handler)
4473              (_("%B: warning: allocated section `%s' not in segment"),
4474               abfd,
4475               (hdr->bfd_section == NULL
4476                ? "*unknown*"
4477                : hdr->bfd_section->name)));
4478           /* We don't need to page align empty sections.  */
4479           if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4480             off += vma_page_aligned_bias (hdr->sh_addr, off,
4481                                           bed->maxpagesize);
4482           else
4483             off += vma_page_aligned_bias (hdr->sh_addr, off,
4484                                           hdr->sh_addralign);
4485           off = _bfd_elf_assign_file_position_for_section (hdr, off,
4486                                                            FALSE);
4487         }
4488       else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4489                 && hdr->bfd_section == NULL)
4490                || hdr == i_shdrpp[tdata->symtab_section]
4491                || hdr == i_shdrpp[tdata->symtab_shndx_section]
4492                || hdr == i_shdrpp[tdata->strtab_section])
4493         hdr->sh_offset = -1;
4494       else
4495         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4496
4497       if (i == SHN_LORESERVE - 1)
4498         {
4499           i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4500           hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4501         }
4502     }
4503
4504   /* Now that we have set the section file positions, we can set up
4505      the file positions for the non PT_LOAD segments.  */
4506   count = 0;
4507   filehdr_vaddr = 0;
4508   filehdr_paddr = 0;
4509   phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4510   phdrs_paddr = 0;
4511   phdrs = elf_tdata (abfd)->phdr;
4512   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4513        m != NULL;
4514        m = m->next, p++)
4515     {
4516       ++count;
4517       if (p->p_type != PT_LOAD)
4518         continue;
4519
4520       if (m->includes_filehdr)
4521         {
4522           filehdr_vaddr = p->p_vaddr;
4523           filehdr_paddr = p->p_paddr;
4524         }
4525       if (m->includes_phdrs)
4526         {
4527           phdrs_vaddr = p->p_vaddr;
4528           phdrs_paddr = p->p_paddr;
4529           if (m->includes_filehdr)
4530             {
4531               phdrs_vaddr += bed->s->sizeof_ehdr;
4532               phdrs_paddr += bed->s->sizeof_ehdr;
4533             }
4534         }
4535     }
4536
4537   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4538        m != NULL;
4539        m = m->next, p++)
4540     {
4541       if (m->count != 0)
4542         {
4543           if (p->p_type != PT_LOAD
4544               && (p->p_type != PT_NOTE
4545                   || bfd_get_format (abfd) != bfd_core))
4546             {
4547               Elf_Internal_Shdr *hdr;
4548               asection *sect;
4549
4550               BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4551
4552               sect = m->sections[m->count - 1];
4553               hdr = &elf_section_data (sect)->this_hdr;
4554               p->p_filesz = sect->filepos - m->sections[0]->filepos;
4555               if (hdr->sh_type != SHT_NOBITS)
4556                 p->p_filesz += hdr->sh_size;
4557
4558               if (p->p_type == PT_GNU_RELRO)
4559                 {
4560                   /* When we get here, we are copying executable
4561                      or shared library. But we need to use the same
4562                      linker logic.  */
4563                   Elf_Internal_Phdr *lp;
4564
4565                   for (lp = phdrs; lp < phdrs + count; ++lp)
4566                     {
4567                       if (lp->p_type == PT_LOAD
4568                           && lp->p_paddr == p->p_paddr)
4569                         break;
4570                     }
4571
4572                   if (lp < phdrs + count)
4573                     {
4574                       /* We should use p_size if it is valid since it
4575                          may contain the first few bytes of the next
4576                          SEC_ALLOC section.  */
4577                       if (m->p_size_valid)
4578                         p->p_filesz = m->p_size;
4579                       else
4580                         abort ();
4581                       p->p_vaddr = lp->p_vaddr;
4582                       p->p_offset = lp->p_offset;
4583                       p->p_memsz = p->p_filesz;
4584                       p->p_align = 1;
4585                     }
4586                   else
4587                     abort ();
4588                 }
4589               else
4590                 p->p_offset = m->sections[0]->filepos;
4591             }
4592         }
4593       else
4594         {
4595           if (m->includes_filehdr)
4596             {
4597               p->p_vaddr = filehdr_vaddr;
4598               if (! m->p_paddr_valid)
4599                 p->p_paddr = filehdr_paddr;
4600             }
4601           else if (m->includes_phdrs)
4602             {
4603               p->p_vaddr = phdrs_vaddr;
4604               if (! m->p_paddr_valid)
4605                 p->p_paddr = phdrs_paddr;
4606             }
4607           else if (p->p_type == PT_GNU_RELRO)
4608             {
4609               Elf_Internal_Phdr *lp;
4610
4611               for (lp = phdrs; lp < phdrs + count; ++lp)
4612                 {
4613                   if (lp->p_type == PT_LOAD
4614                       && lp->p_vaddr <= link_info->relro_end
4615                       && lp->p_vaddr >= link_info->relro_start
4616                       && (lp->p_vaddr + lp->p_filesz
4617                           >= link_info->relro_end))
4618                     break;
4619                 }
4620
4621               if (lp < phdrs + count
4622                   && link_info->relro_end > lp->p_vaddr)
4623                 {
4624                   p->p_vaddr = lp->p_vaddr;
4625                   p->p_paddr = lp->p_paddr;
4626                   p->p_offset = lp->p_offset;
4627                   p->p_filesz = link_info->relro_end - lp->p_vaddr;
4628                   p->p_memsz = p->p_filesz;
4629                   p->p_align = 1;
4630                   p->p_flags = (lp->p_flags & ~PF_W);
4631                 }
4632               else
4633                 {
4634                   memset (p, 0, sizeof *p);
4635                   p->p_type = PT_NULL;
4636                 }
4637             }
4638         }
4639     }
4640
4641   elf_tdata (abfd)->next_file_pos = off;
4642
4643   return TRUE;
4644 }
4645
4646 /* Work out the file positions of all the sections.  This is called by
4647    _bfd_elf_compute_section_file_positions.  All the section sizes and
4648    VMAs must be known before this is called.
4649
4650    Reloc sections come in two flavours: Those processed specially as
4651    "side-channel" data attached to a section to which they apply, and
4652    those that bfd doesn't process as relocations.  The latter sort are
4653    stored in a normal bfd section by bfd_section_from_shdr.   We don't
4654    consider the former sort here, unless they form part of the loadable
4655    image.  Reloc sections not assigned here will be handled later by
4656    assign_file_positions_for_relocs.
4657
4658    We also don't set the positions of the .symtab and .strtab here.  */
4659
4660 static bfd_boolean
4661 assign_file_positions_except_relocs (bfd *abfd,
4662                                      struct bfd_link_info *link_info)
4663 {
4664   struct elf_obj_tdata *tdata = elf_tdata (abfd);
4665   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4666   file_ptr off;
4667   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4668
4669   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4670       && bfd_get_format (abfd) != bfd_core)
4671     {
4672       Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4673       unsigned int num_sec = elf_numsections (abfd);
4674       Elf_Internal_Shdr **hdrpp;
4675       unsigned int i;
4676
4677       /* Start after the ELF header.  */
4678       off = i_ehdrp->e_ehsize;
4679
4680       /* We are not creating an executable, which means that we are
4681          not creating a program header, and that the actual order of
4682          the sections in the file is unimportant.  */
4683       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4684         {
4685           Elf_Internal_Shdr *hdr;
4686
4687           hdr = *hdrpp;
4688           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4689                && hdr->bfd_section == NULL)
4690               || i == tdata->symtab_section
4691               || i == tdata->symtab_shndx_section
4692               || i == tdata->strtab_section)
4693             {
4694               hdr->sh_offset = -1;
4695             }
4696           else
4697             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4698
4699           if (i == SHN_LORESERVE - 1)
4700             {
4701               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4702               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4703             }
4704         }
4705     }
4706   else
4707     {
4708       unsigned int alloc;
4709
4710       /* Assign file positions for the loaded sections based on the
4711          assignment of sections to segments.  */
4712       if (!assign_file_positions_for_load_sections (abfd, link_info))
4713         return FALSE;
4714
4715       /* And for non-load sections.  */
4716       if (!assign_file_positions_for_non_load_sections (abfd, link_info))
4717         return FALSE;
4718
4719       if (bed->elf_backend_modify_program_headers != NULL)
4720         {
4721           if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
4722             return FALSE;
4723         }
4724
4725       /* Write out the program headers.  */
4726       alloc = tdata->program_header_size / bed->s->sizeof_phdr;
4727       if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4728           || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
4729         return FALSE;
4730
4731       off = tdata->next_file_pos;
4732     }
4733
4734   /* Place the section headers.  */
4735   off = align_file_position (off, 1 << bed->s->log_file_align);
4736   i_ehdrp->e_shoff = off;
4737   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4738
4739   tdata->next_file_pos = off;
4740
4741   return TRUE;
4742 }
4743
4744 static bfd_boolean
4745 prep_headers (bfd *abfd)
4746 {
4747   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
4748   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4749   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
4750   struct elf_strtab_hash *shstrtab;
4751   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4752
4753   i_ehdrp = elf_elfheader (abfd);
4754   i_shdrp = elf_elfsections (abfd);
4755
4756   shstrtab = _bfd_elf_strtab_init ();
4757   if (shstrtab == NULL)
4758     return FALSE;
4759
4760   elf_shstrtab (abfd) = shstrtab;
4761
4762   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4763   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4764   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4765   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4766
4767   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4768   i_ehdrp->e_ident[EI_DATA] =
4769     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4770   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4771
4772   if ((abfd->flags & DYNAMIC) != 0)
4773     i_ehdrp->e_type = ET_DYN;
4774   else if ((abfd->flags & EXEC_P) != 0)
4775     i_ehdrp->e_type = ET_EXEC;
4776   else if (bfd_get_format (abfd) == bfd_core)
4777     i_ehdrp->e_type = ET_CORE;
4778   else
4779     i_ehdrp->e_type = ET_REL;
4780
4781   switch (bfd_get_arch (abfd))
4782     {
4783     case bfd_arch_unknown:
4784       i_ehdrp->e_machine = EM_NONE;
4785       break;
4786
4787       /* There used to be a long list of cases here, each one setting
4788          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4789          in the corresponding bfd definition.  To avoid duplication,
4790          the switch was removed.  Machines that need special handling
4791          can generally do it in elf_backend_final_write_processing(),
4792          unless they need the information earlier than the final write.
4793          Such need can generally be supplied by replacing the tests for
4794          e_machine with the conditions used to determine it.  */
4795     default:
4796       i_ehdrp->e_machine = bed->elf_machine_code;
4797     }
4798
4799   i_ehdrp->e_version = bed->s->ev_current;
4800   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4801
4802   /* No program header, for now.  */
4803   i_ehdrp->e_phoff = 0;
4804   i_ehdrp->e_phentsize = 0;
4805   i_ehdrp->e_phnum = 0;
4806
4807   /* Each bfd section is section header entry.  */
4808   i_ehdrp->e_entry = bfd_get_start_address (abfd);
4809   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4810
4811   /* If we're building an executable, we'll need a program header table.  */
4812   if (abfd->flags & EXEC_P)
4813     /* It all happens later.  */
4814     ;
4815   else
4816     {
4817       i_ehdrp->e_phentsize = 0;
4818       i_phdrp = 0;
4819       i_ehdrp->e_phoff = 0;
4820     }
4821
4822   elf_tdata (abfd)->symtab_hdr.sh_name =
4823     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4824   elf_tdata (abfd)->strtab_hdr.sh_name =
4825     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4826   elf_tdata (abfd)->shstrtab_hdr.sh_name =
4827     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4828   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4829       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4830       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4831     return FALSE;
4832
4833   return TRUE;
4834 }
4835
4836 /* Assign file positions for all the reloc sections which are not part
4837    of the loadable file image.  */
4838
4839 void
4840 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4841 {
4842   file_ptr off;
4843   unsigned int i, num_sec;
4844   Elf_Internal_Shdr **shdrpp;
4845
4846   off = elf_tdata (abfd)->next_file_pos;
4847
4848   num_sec = elf_numsections (abfd);
4849   for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4850     {
4851       Elf_Internal_Shdr *shdrp;
4852
4853       shdrp = *shdrpp;
4854       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4855           && shdrp->sh_offset == -1)
4856         off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4857     }
4858
4859   elf_tdata (abfd)->next_file_pos = off;
4860 }
4861
4862 bfd_boolean
4863 _bfd_elf_write_object_contents (bfd *abfd)
4864 {
4865   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4866   Elf_Internal_Ehdr *i_ehdrp;
4867   Elf_Internal_Shdr **i_shdrp;
4868   bfd_boolean failed;
4869   unsigned int count, num_sec;
4870
4871   if (! abfd->output_has_begun
4872       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4873     return FALSE;
4874
4875   i_shdrp = elf_elfsections (abfd);
4876   i_ehdrp = elf_elfheader (abfd);
4877
4878   failed = FALSE;
4879   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4880   if (failed)
4881     return FALSE;
4882
4883   _bfd_elf_assign_file_positions_for_relocs (abfd);
4884
4885   /* After writing the headers, we need to write the sections too...  */
4886   num_sec = elf_numsections (abfd);
4887   for (count = 1; count < num_sec; count++)
4888     {
4889       if (bed->elf_backend_section_processing)
4890         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4891       if (i_shdrp[count]->contents)
4892         {
4893           bfd_size_type amt = i_shdrp[count]->sh_size;
4894
4895           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4896               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4897             return FALSE;
4898         }
4899       if (count == SHN_LORESERVE - 1)
4900         count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4901     }
4902
4903   /* Write out the section header names.  */
4904   if (elf_shstrtab (abfd) != NULL
4905       && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4906           || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
4907     return FALSE;
4908
4909   if (bed->elf_backend_final_write_processing)
4910     (*bed->elf_backend_final_write_processing) (abfd,
4911                                                 elf_tdata (abfd)->linker);
4912
4913   if (!bed->s->write_shdrs_and_ehdr (abfd))
4914     return FALSE;
4915
4916   /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0].  */
4917   if (elf_tdata (abfd)->after_write_object_contents)
4918     return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
4919
4920   return TRUE;
4921 }
4922
4923 bfd_boolean
4924 _bfd_elf_write_corefile_contents (bfd *abfd)
4925 {
4926   /* Hopefully this can be done just like an object file.  */
4927   return _bfd_elf_write_object_contents (abfd);
4928 }
4929
4930 /* Given a section, search the header to find them.  */
4931
4932 int
4933 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
4934 {
4935   const struct elf_backend_data *bed;
4936   int index;
4937
4938   if (elf_section_data (asect) != NULL
4939       && elf_section_data (asect)->this_idx != 0)
4940     return elf_section_data (asect)->this_idx;
4941
4942   if (bfd_is_abs_section (asect))
4943     index = SHN_ABS;
4944   else if (bfd_is_com_section (asect))
4945     index = SHN_COMMON;
4946   else if (bfd_is_und_section (asect))
4947     index = SHN_UNDEF;
4948   else
4949     index = -1;
4950
4951   bed = get_elf_backend_data (abfd);
4952   if (bed->elf_backend_section_from_bfd_section)
4953     {
4954       int retval = index;
4955
4956       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4957         return retval;
4958     }
4959
4960   if (index == -1)
4961     bfd_set_error (bfd_error_nonrepresentable_section);
4962
4963   return index;
4964 }
4965
4966 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4967    on error.  */
4968
4969 int
4970 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
4971 {
4972   asymbol *asym_ptr = *asym_ptr_ptr;
4973   int idx;
4974   flagword flags = asym_ptr->flags;
4975
4976   /* When gas creates relocations against local labels, it creates its
4977      own symbol for the section, but does put the symbol into the
4978      symbol chain, so udata is 0.  When the linker is generating
4979      relocatable output, this section symbol may be for one of the
4980      input sections rather than the output section.  */
4981   if (asym_ptr->udata.i == 0
4982       && (flags & BSF_SECTION_SYM)
4983       && asym_ptr->section)
4984     {
4985       asection *sec;
4986       int indx;
4987
4988       sec = asym_ptr->section;
4989       if (sec->owner != abfd && sec->output_section != NULL)
4990         sec = sec->output_section;
4991       if (sec->owner == abfd
4992           && (indx = sec->index) < elf_num_section_syms (abfd)
4993           && elf_section_syms (abfd)[indx] != NULL)
4994         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4995     }
4996
4997   idx = asym_ptr->udata.i;
4998
4999   if (idx == 0)
5000     {
5001       /* This case can occur when using --strip-symbol on a symbol
5002          which is used in a relocation entry.  */
5003       (*_bfd_error_handler)
5004         (_("%B: symbol `%s' required but not present"),
5005          abfd, bfd_asymbol_name (asym_ptr));
5006       bfd_set_error (bfd_error_no_symbols);
5007       return -1;
5008     }
5009
5010 #if DEBUG & 4
5011   {
5012     fprintf (stderr,
5013              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5014              (long) asym_ptr, asym_ptr->name, idx, flags,
5015              elf_symbol_flags (flags));
5016     fflush (stderr);
5017   }
5018 #endif
5019
5020   return idx;
5021 }
5022
5023 /* Rewrite program header information.  */
5024
5025 static bfd_boolean
5026 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5027 {
5028   Elf_Internal_Ehdr *iehdr;
5029   struct elf_segment_map *map;
5030   struct elf_segment_map *map_first;
5031   struct elf_segment_map **pointer_to_map;
5032   Elf_Internal_Phdr *segment;
5033   asection *section;
5034   unsigned int i;
5035   unsigned int num_segments;
5036   bfd_boolean phdr_included = FALSE;
5037   bfd_vma maxpagesize;
5038   struct elf_segment_map *phdr_adjust_seg = NULL;
5039   unsigned int phdr_adjust_num = 0;
5040   const struct elf_backend_data *bed;
5041
5042   bed = get_elf_backend_data (ibfd);
5043   iehdr = elf_elfheader (ibfd);
5044
5045   map_first = NULL;
5046   pointer_to_map = &map_first;
5047
5048   num_segments = elf_elfheader (ibfd)->e_phnum;
5049   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5050
5051   /* Returns the end address of the segment + 1.  */
5052 #define SEGMENT_END(segment, start)                                     \
5053   (start + (segment->p_memsz > segment->p_filesz                        \
5054             ? segment->p_memsz : segment->p_filesz))
5055
5056 #define SECTION_SIZE(section, segment)                                  \
5057   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
5058     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
5059    ? section->size : 0)
5060
5061   /* Returns TRUE if the given section is contained within
5062      the given segment.  VMA addresses are compared.  */
5063 #define IS_CONTAINED_BY_VMA(section, segment)                           \
5064   (section->vma >= segment->p_vaddr                                     \
5065    && (section->vma + SECTION_SIZE (section, segment)                   \
5066        <= (SEGMENT_END (segment, segment->p_vaddr))))
5067
5068   /* Returns TRUE if the given section is contained within
5069      the given segment.  LMA addresses are compared.  */
5070 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
5071   (section->lma >= base                                                 \
5072    && (section->lma + SECTION_SIZE (section, segment)                   \
5073        <= SEGMENT_END (segment, base)))
5074
5075   /* Special case: corefile "NOTE" section containing regs, prpsinfo etc.  */
5076 #define IS_COREFILE_NOTE(p, s)                                          \
5077   (p->p_type == PT_NOTE                                                 \
5078    && bfd_get_format (ibfd) == bfd_core                                 \
5079    && s->vma == 0 && s->lma == 0                                        \
5080    && (bfd_vma) s->filepos >= p->p_offset                               \
5081    && ((bfd_vma) s->filepos + s->size                                   \
5082        <= p->p_offset + p->p_filesz))
5083
5084   /* The complicated case when p_vaddr is 0 is to handle the Solaris
5085      linker, which generates a PT_INTERP section with p_vaddr and
5086      p_memsz set to 0.  */
5087 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
5088   (p->p_vaddr == 0                                                      \
5089    && p->p_paddr == 0                                                   \
5090    && p->p_memsz == 0                                                   \
5091    && p->p_filesz > 0                                                   \
5092    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
5093    && s->size > 0                                                       \
5094    && (bfd_vma) s->filepos >= p->p_offset                               \
5095    && ((bfd_vma) s->filepos + s->size                                   \
5096        <= p->p_offset + p->p_filesz))
5097
5098   /* Decide if the given section should be included in the given segment.
5099      A section will be included if:
5100        1. It is within the address space of the segment -- we use the LMA
5101           if that is set for the segment and the VMA otherwise,
5102        2. It is an allocated segment,
5103        3. There is an output section associated with it,
5104        4. The section has not already been allocated to a previous segment.
5105        5. PT_GNU_STACK segments do not include any sections.
5106        6. PT_TLS segment includes only SHF_TLS sections.
5107        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5108        8. PT_DYNAMIC should not contain empty sections at the beginning
5109           (with the possible exception of .dynamic).  */
5110 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed)              \
5111   ((((segment->p_paddr                                                  \
5112       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
5113       : IS_CONTAINED_BY_VMA (section, segment))                         \
5114      && (section->flags & SEC_ALLOC) != 0)                              \
5115     || IS_COREFILE_NOTE (segment, section))                             \
5116    && segment->p_type != PT_GNU_STACK                                   \
5117    && (segment->p_type != PT_TLS                                        \
5118        || (section->flags & SEC_THREAD_LOCAL))                          \
5119    && (segment->p_type == PT_LOAD                                       \
5120        || segment->p_type == PT_TLS                                     \
5121        || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
5122    && (segment->p_type != PT_DYNAMIC                                    \
5123        || SECTION_SIZE (section, segment) > 0                           \
5124        || (segment->p_paddr                                             \
5125            ? segment->p_paddr != section->lma                           \
5126            : segment->p_vaddr != section->vma)                          \
5127        || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic")    \
5128            == 0))                                                       \
5129    && ! section->segment_mark)
5130
5131 /* If the output section of a section in the input segment is NULL,
5132    it is removed from the corresponding output segment.   */
5133 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
5134   (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed)          \
5135    && section->output_section != NULL)
5136
5137   /* Returns TRUE iff seg1 starts after the end of seg2.  */
5138 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
5139   (seg1->field >= SEGMENT_END (seg2, seg2->field))
5140
5141   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5142      their VMA address ranges and their LMA address ranges overlap.
5143      It is possible to have overlapping VMA ranges without overlapping LMA
5144      ranges.  RedBoot images for example can have both .data and .bss mapped
5145      to the same VMA range, but with the .data section mapped to a different
5146      LMA.  */
5147 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
5148   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
5149         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
5150    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
5151         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5152
5153   /* Initialise the segment mark field.  */
5154   for (section = ibfd->sections; section != NULL; section = section->next)
5155     section->segment_mark = FALSE;
5156
5157   /* Scan through the segments specified in the program header
5158      of the input BFD.  For this first scan we look for overlaps
5159      in the loadable segments.  These can be created by weird
5160      parameters to objcopy.  Also, fix some solaris weirdness.  */
5161   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5162        i < num_segments;
5163        i++, segment++)
5164     {
5165       unsigned int j;
5166       Elf_Internal_Phdr *segment2;
5167
5168       if (segment->p_type == PT_INTERP)
5169         for (section = ibfd->sections; section; section = section->next)
5170           if (IS_SOLARIS_PT_INTERP (segment, section))
5171             {
5172               /* Mininal change so that the normal section to segment
5173                  assignment code will work.  */
5174               segment->p_vaddr = section->vma;
5175               break;
5176             }
5177
5178       if (segment->p_type != PT_LOAD)
5179         {
5180           /* Remove PT_GNU_RELRO segment.  */
5181           if (segment->p_type == PT_GNU_RELRO)
5182             segment->p_type = PT_NULL;
5183           continue;
5184         }
5185
5186       /* Determine if this segment overlaps any previous segments.  */
5187       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
5188         {
5189           bfd_signed_vma extra_length;
5190
5191           if (segment2->p_type != PT_LOAD
5192               || ! SEGMENT_OVERLAPS (segment, segment2))
5193             continue;
5194
5195           /* Merge the two segments together.  */
5196           if (segment2->p_vaddr < segment->p_vaddr)
5197             {
5198               /* Extend SEGMENT2 to include SEGMENT and then delete
5199                  SEGMENT.  */
5200               extra_length =
5201                 SEGMENT_END (segment, segment->p_vaddr)
5202                 - SEGMENT_END (segment2, segment2->p_vaddr);
5203
5204               if (extra_length > 0)
5205                 {
5206                   segment2->p_memsz  += extra_length;
5207                   segment2->p_filesz += extra_length;
5208                 }
5209
5210               segment->p_type = PT_NULL;
5211
5212               /* Since we have deleted P we must restart the outer loop.  */
5213               i = 0;
5214               segment = elf_tdata (ibfd)->phdr;
5215               break;
5216             }
5217           else
5218             {
5219               /* Extend SEGMENT to include SEGMENT2 and then delete
5220                  SEGMENT2.  */
5221               extra_length =
5222                 SEGMENT_END (segment2, segment2->p_vaddr)
5223                 - SEGMENT_END (segment, segment->p_vaddr);
5224
5225               if (extra_length > 0)
5226                 {
5227                   segment->p_memsz  += extra_length;
5228                   segment->p_filesz += extra_length;
5229                 }
5230
5231               segment2->p_type = PT_NULL;
5232             }
5233         }
5234     }
5235
5236   /* The second scan attempts to assign sections to segments.  */
5237   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5238        i < num_segments;
5239        i ++, segment ++)
5240     {
5241       unsigned int  section_count;
5242       asection **   sections;
5243       asection *    output_section;
5244       unsigned int  isec;
5245       bfd_vma       matching_lma;
5246       bfd_vma       suggested_lma;
5247       unsigned int  j;
5248       bfd_size_type amt;
5249       asection *    first_section;
5250
5251       if (segment->p_type == PT_NULL)
5252         continue;
5253
5254       first_section = NULL;
5255       /* Compute how many sections might be placed into this segment.  */
5256       for (section = ibfd->sections, section_count = 0;
5257            section != NULL;
5258            section = section->next)
5259         {
5260           /* Find the first section in the input segment, which may be
5261              removed from the corresponding output segment.   */
5262           if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5263             {
5264               if (first_section == NULL)
5265                 first_section = section;
5266               if (section->output_section != NULL)
5267                 ++section_count;
5268             }
5269         }
5270
5271       /* Allocate a segment map big enough to contain
5272          all of the sections we have selected.  */
5273       amt = sizeof (struct elf_segment_map);
5274       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5275       map = bfd_zalloc (obfd, amt);
5276       if (map == NULL)
5277         return FALSE;
5278
5279       /* Initialise the fields of the segment map.  Default to
5280          using the physical address of the segment in the input BFD.  */
5281       map->next          = NULL;
5282       map->p_type        = segment->p_type;
5283       map->p_flags       = segment->p_flags;
5284       map->p_flags_valid = 1;
5285
5286       /* If the first section in the input segment is removed, there is
5287          no need to preserve segment physical address in the corresponding
5288          output segment.  */
5289       if (!first_section || first_section->output_section != NULL)
5290         {
5291           map->p_paddr = segment->p_paddr;
5292           map->p_paddr_valid = 1;
5293         }
5294
5295       /* Determine if this segment contains the ELF file header
5296          and if it contains the program headers themselves.  */
5297       map->includes_filehdr = (segment->p_offset == 0
5298                                && segment->p_filesz >= iehdr->e_ehsize);
5299
5300       map->includes_phdrs = 0;
5301
5302       if (! phdr_included || segment->p_type != PT_LOAD)
5303         {
5304           map->includes_phdrs =
5305             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5306              && (segment->p_offset + segment->p_filesz
5307                  >= ((bfd_vma) iehdr->e_phoff
5308                      + iehdr->e_phnum * iehdr->e_phentsize)));
5309
5310           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5311             phdr_included = TRUE;
5312         }
5313
5314       if (section_count == 0)
5315         {
5316           /* Special segments, such as the PT_PHDR segment, may contain
5317              no sections, but ordinary, loadable segments should contain
5318              something.  They are allowed by the ELF spec however, so only
5319              a warning is produced.  */
5320           if (segment->p_type == PT_LOAD)
5321             (*_bfd_error_handler)
5322               (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5323                ibfd);
5324
5325           map->count = 0;
5326           *pointer_to_map = map;
5327           pointer_to_map = &map->next;
5328
5329           continue;
5330         }
5331
5332       /* Now scan the sections in the input BFD again and attempt
5333          to add their corresponding output sections to the segment map.
5334          The problem here is how to handle an output section which has
5335          been moved (ie had its LMA changed).  There are four possibilities:
5336
5337          1. None of the sections have been moved.
5338             In this case we can continue to use the segment LMA from the
5339             input BFD.
5340
5341          2. All of the sections have been moved by the same amount.
5342             In this case we can change the segment's LMA to match the LMA
5343             of the first section.
5344
5345          3. Some of the sections have been moved, others have not.
5346             In this case those sections which have not been moved can be
5347             placed in the current segment which will have to have its size,
5348             and possibly its LMA changed, and a new segment or segments will
5349             have to be created to contain the other sections.
5350
5351          4. The sections have been moved, but not by the same amount.
5352             In this case we can change the segment's LMA to match the LMA
5353             of the first section and we will have to create a new segment
5354             or segments to contain the other sections.
5355
5356          In order to save time, we allocate an array to hold the section
5357          pointers that we are interested in.  As these sections get assigned
5358          to a segment, they are removed from this array.  */
5359
5360       /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5361          to work around this long long bug.  */
5362       sections = bfd_malloc2 (section_count, sizeof (asection *));
5363       if (sections == NULL)
5364         return FALSE;
5365
5366       /* Step One: Scan for segment vs section LMA conflicts.
5367          Also add the sections to the section array allocated above.
5368          Also add the sections to the current segment.  In the common
5369          case, where the sections have not been moved, this means that
5370          we have completely filled the segment, and there is nothing
5371          more to do.  */
5372       isec = 0;
5373       matching_lma = 0;
5374       suggested_lma = 0;
5375
5376       for (j = 0, section = ibfd->sections;
5377            section != NULL;
5378            section = section->next)
5379         {
5380           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5381             {
5382               output_section = section->output_section;
5383
5384               sections[j ++] = section;
5385
5386               /* The Solaris native linker always sets p_paddr to 0.
5387                  We try to catch that case here, and set it to the
5388                  correct value.  Note - some backends require that
5389                  p_paddr be left as zero.  */
5390               if (segment->p_paddr == 0
5391                   && segment->p_vaddr != 0
5392                   && (! bed->want_p_paddr_set_to_zero)
5393                   && isec == 0
5394                   && output_section->lma != 0
5395                   && (output_section->vma == (segment->p_vaddr
5396                                               + (map->includes_filehdr
5397                                                  ? iehdr->e_ehsize
5398                                                  : 0)
5399                                               + (map->includes_phdrs
5400                                                  ? (iehdr->e_phnum
5401                                                     * iehdr->e_phentsize)
5402                                                  : 0))))
5403                 map->p_paddr = segment->p_vaddr;
5404
5405               /* Match up the physical address of the segment with the
5406                  LMA address of the output section.  */
5407               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5408                   || IS_COREFILE_NOTE (segment, section)
5409                   || (bed->want_p_paddr_set_to_zero &&
5410                       IS_CONTAINED_BY_VMA (output_section, segment)))
5411                 {
5412                   if (matching_lma == 0 || output_section->lma < matching_lma)
5413                     matching_lma = output_section->lma;
5414
5415                   /* We assume that if the section fits within the segment
5416                      then it does not overlap any other section within that
5417                      segment.  */
5418                   map->sections[isec ++] = output_section;
5419                 }
5420               else if (suggested_lma == 0)
5421                 suggested_lma = output_section->lma;
5422             }
5423         }
5424
5425       BFD_ASSERT (j == section_count);
5426
5427       /* Step Two: Adjust the physical address of the current segment,
5428          if necessary.  */
5429       if (isec == section_count)
5430         {
5431           /* All of the sections fitted within the segment as currently
5432              specified.  This is the default case.  Add the segment to
5433              the list of built segments and carry on to process the next
5434              program header in the input BFD.  */
5435           map->count = section_count;
5436           *pointer_to_map = map;
5437           pointer_to_map = &map->next;
5438
5439           if (matching_lma != map->p_paddr
5440               && !map->includes_filehdr && !map->includes_phdrs)
5441             /* There is some padding before the first section in the
5442                segment.  So, we must account for that in the output
5443                segment's vma.  */
5444             map->p_vaddr_offset = matching_lma - map->p_paddr;
5445
5446           free (sections);
5447           continue;
5448         }
5449       else
5450         {
5451           if (matching_lma != 0)
5452             {
5453               /* At least one section fits inside the current segment.
5454                  Keep it, but modify its physical address to match the
5455                  LMA of the first section that fitted.  */
5456               map->p_paddr = matching_lma;
5457             }
5458           else
5459             {
5460               /* None of the sections fitted inside the current segment.
5461                  Change the current segment's physical address to match
5462                  the LMA of the first section.  */
5463               map->p_paddr = suggested_lma;
5464             }
5465
5466           /* Offset the segment physical address from the lma
5467              to allow for space taken up by elf headers.  */
5468           if (map->includes_filehdr)
5469             map->p_paddr -= iehdr->e_ehsize;
5470
5471           if (map->includes_phdrs)
5472             {
5473               map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5474
5475               /* iehdr->e_phnum is just an estimate of the number
5476                  of program headers that we will need.  Make a note
5477                  here of the number we used and the segment we chose
5478                  to hold these headers, so that we can adjust the
5479                  offset when we know the correct value.  */
5480               phdr_adjust_num = iehdr->e_phnum;
5481               phdr_adjust_seg = map;
5482             }
5483         }
5484
5485       /* Step Three: Loop over the sections again, this time assigning
5486          those that fit to the current segment and removing them from the
5487          sections array; but making sure not to leave large gaps.  Once all
5488          possible sections have been assigned to the current segment it is
5489          added to the list of built segments and if sections still remain
5490          to be assigned, a new segment is constructed before repeating
5491          the loop.  */
5492       isec = 0;
5493       do
5494         {
5495           map->count = 0;
5496           suggested_lma = 0;
5497
5498           /* Fill the current segment with sections that fit.  */
5499           for (j = 0; j < section_count; j++)
5500             {
5501               section = sections[j];
5502
5503               if (section == NULL)
5504                 continue;
5505
5506               output_section = section->output_section;
5507
5508               BFD_ASSERT (output_section != NULL);
5509
5510               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5511                   || IS_COREFILE_NOTE (segment, section))
5512                 {
5513                   if (map->count == 0)
5514                     {
5515                       /* If the first section in a segment does not start at
5516                          the beginning of the segment, then something is
5517                          wrong.  */
5518                       if (output_section->lma !=
5519                           (map->p_paddr
5520                            + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5521                            + (map->includes_phdrs
5522                               ? iehdr->e_phnum * iehdr->e_phentsize
5523                               : 0)))
5524                         abort ();
5525                     }
5526                   else
5527                     {
5528                       asection * prev_sec;
5529
5530                       prev_sec = map->sections[map->count - 1];
5531
5532                       /* If the gap between the end of the previous section
5533                          and the start of this section is more than
5534                          maxpagesize then we need to start a new segment.  */
5535                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5536                                       maxpagesize)
5537                            < BFD_ALIGN (output_section->lma, maxpagesize))
5538                           || ((prev_sec->lma + prev_sec->size)
5539                               > output_section->lma))
5540                         {
5541                           if (suggested_lma == 0)
5542                             suggested_lma = output_section->lma;
5543
5544                           continue;
5545                         }
5546                     }
5547
5548                   map->sections[map->count++] = output_section;
5549                   ++isec;
5550                   sections[j] = NULL;
5551                   section->segment_mark = TRUE;
5552                 }
5553               else if (suggested_lma == 0)
5554                 suggested_lma = output_section->lma;
5555             }
5556
5557           BFD_ASSERT (map->count > 0);
5558
5559           /* Add the current segment to the list of built segments.  */
5560           *pointer_to_map = map;
5561           pointer_to_map = &map->next;
5562
5563           if (isec < section_count)
5564             {
5565               /* We still have not allocated all of the sections to
5566                  segments.  Create a new segment here, initialise it
5567                  and carry on looping.  */
5568               amt = sizeof (struct elf_segment_map);
5569               amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5570               map = bfd_alloc (obfd, amt);
5571               if (map == NULL)
5572                 {
5573                   free (sections);
5574                   return FALSE;
5575                 }
5576
5577               /* Initialise the fields of the segment map.  Set the physical
5578                  physical address to the LMA of the first section that has
5579                  not yet been assigned.  */
5580               map->next             = NULL;
5581               map->p_type           = segment->p_type;
5582               map->p_flags          = segment->p_flags;
5583               map->p_flags_valid    = 1;
5584               map->p_paddr          = suggested_lma;
5585               map->p_paddr_valid    = 1;
5586               map->includes_filehdr = 0;
5587               map->includes_phdrs   = 0;
5588             }
5589         }
5590       while (isec < section_count);
5591
5592       free (sections);
5593     }
5594
5595   /* The Solaris linker creates program headers in which all the
5596      p_paddr fields are zero.  When we try to objcopy or strip such a
5597      file, we get confused.  Check for this case, and if we find it
5598      reset the p_paddr_valid fields.  */
5599   for (map = map_first; map != NULL; map = map->next)
5600     if (map->p_paddr != 0)
5601       break;
5602   if (map == NULL)
5603     for (map = map_first; map != NULL; map = map->next)
5604       map->p_paddr_valid = 0;
5605
5606   elf_tdata (obfd)->segment_map = map_first;
5607
5608   /* If we had to estimate the number of program headers that were
5609      going to be needed, then check our estimate now and adjust
5610      the offset if necessary.  */
5611   if (phdr_adjust_seg != NULL)
5612     {
5613       unsigned int count;
5614
5615       for (count = 0, map = map_first; map != NULL; map = map->next)
5616         count++;
5617
5618       if (count > phdr_adjust_num)
5619         phdr_adjust_seg->p_paddr
5620           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5621     }
5622
5623 #undef SEGMENT_END
5624 #undef SECTION_SIZE
5625 #undef IS_CONTAINED_BY_VMA
5626 #undef IS_CONTAINED_BY_LMA
5627 #undef IS_COREFILE_NOTE
5628 #undef IS_SOLARIS_PT_INTERP
5629 #undef IS_SECTION_IN_INPUT_SEGMENT
5630 #undef INCLUDE_SECTION_IN_SEGMENT
5631 #undef SEGMENT_AFTER_SEGMENT
5632 #undef SEGMENT_OVERLAPS
5633   return TRUE;
5634 }
5635
5636 /* Copy ELF program header information.  */
5637
5638 static bfd_boolean
5639 copy_elf_program_header (bfd *ibfd, bfd *obfd)
5640 {
5641   Elf_Internal_Ehdr *iehdr;
5642   struct elf_segment_map *map;
5643   struct elf_segment_map *map_first;
5644   struct elf_segment_map **pointer_to_map;
5645   Elf_Internal_Phdr *segment;
5646   unsigned int i;
5647   unsigned int num_segments;
5648   bfd_boolean phdr_included = FALSE;
5649
5650   iehdr = elf_elfheader (ibfd);
5651
5652   map_first = NULL;
5653   pointer_to_map = &map_first;
5654
5655   num_segments = elf_elfheader (ibfd)->e_phnum;
5656   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5657        i < num_segments;
5658        i++, segment++)
5659     {
5660       asection *section;
5661       unsigned int section_count;
5662       bfd_size_type amt;
5663       Elf_Internal_Shdr *this_hdr;
5664       asection *first_section = NULL;
5665       asection *lowest_section = NULL;
5666
5667       /* FIXME: Do we need to copy PT_NULL segment?  */
5668       if (segment->p_type == PT_NULL)
5669         continue;
5670
5671       /* Compute how many sections are in this segment.  */
5672       for (section = ibfd->sections, section_count = 0;
5673            section != NULL;
5674            section = section->next)
5675         {
5676           this_hdr = &(elf_section_data(section)->this_hdr);
5677           if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5678             {
5679               if (!first_section)
5680                 first_section = lowest_section = section;
5681               if (section->lma < lowest_section->lma)
5682                 lowest_section = section;
5683               section_count++;
5684             }
5685         }
5686
5687       /* Allocate a segment map big enough to contain
5688          all of the sections we have selected.  */
5689       amt = sizeof (struct elf_segment_map);
5690       if (section_count != 0)
5691         amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5692       map = bfd_zalloc (obfd, amt);
5693       if (map == NULL)
5694         return FALSE;
5695
5696       /* Initialize the fields of the output segment map with the
5697          input segment.  */
5698       map->next = NULL;
5699       map->p_type = segment->p_type;
5700       map->p_flags = segment->p_flags;
5701       map->p_flags_valid = 1;
5702       map->p_paddr = segment->p_paddr;
5703       map->p_paddr_valid = 1;
5704       map->p_align = segment->p_align;
5705       map->p_align_valid = 1;
5706       map->p_vaddr_offset = 0;
5707
5708       if (map->p_type == PT_GNU_RELRO
5709           && segment->p_filesz == segment->p_memsz)
5710         {
5711           /* The PT_GNU_RELRO segment may contain the first a few
5712              bytes in the .got.plt section even if the whole .got.plt
5713              section isn't in the PT_GNU_RELRO segment.  We won't
5714              change the size of the PT_GNU_RELRO segment.  */
5715           map->p_size = segment->p_filesz;
5716           map->p_size_valid = 1;
5717         }
5718
5719       /* Determine if this segment contains the ELF file header
5720          and if it contains the program headers themselves.  */
5721       map->includes_filehdr = (segment->p_offset == 0
5722                                && segment->p_filesz >= iehdr->e_ehsize);
5723
5724       map->includes_phdrs = 0;
5725       if (! phdr_included || segment->p_type != PT_LOAD)
5726         {
5727           map->includes_phdrs =
5728             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5729              && (segment->p_offset + segment->p_filesz
5730                  >= ((bfd_vma) iehdr->e_phoff
5731                      + iehdr->e_phnum * iehdr->e_phentsize)));
5732
5733           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5734             phdr_included = TRUE;
5735         }
5736
5737       if (!map->includes_phdrs && !map->includes_filehdr)
5738         /* There is some other padding before the first section.  */
5739         map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
5740                                - segment->p_paddr);
5741
5742       if (section_count != 0)
5743         {
5744           unsigned int isec = 0;
5745
5746           for (section = first_section;
5747                section != NULL;
5748                section = section->next)
5749             {
5750               this_hdr = &(elf_section_data(section)->this_hdr);
5751               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5752                 {
5753                   map->sections[isec++] = section->output_section;
5754                   if (isec == section_count)
5755                     break;
5756                 }
5757             }
5758         }
5759
5760       map->count = section_count;
5761       *pointer_to_map = map;
5762       pointer_to_map = &map->next;
5763     }
5764
5765   elf_tdata (obfd)->segment_map = map_first;
5766   return TRUE;
5767 }
5768
5769 /* Copy private BFD data.  This copies or rewrites ELF program header
5770    information.  */
5771
5772 static bfd_boolean
5773 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5774 {
5775   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5776       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5777     return TRUE;
5778
5779   if (elf_tdata (ibfd)->phdr == NULL)
5780     return TRUE;
5781
5782   if (ibfd->xvec == obfd->xvec)
5783     {
5784       /* Check to see if any sections in the input BFD
5785          covered by ELF program header have changed.  */
5786       Elf_Internal_Phdr *segment;
5787       asection *section, *osec;
5788       unsigned int i, num_segments;
5789       Elf_Internal_Shdr *this_hdr;
5790
5791       /* Initialize the segment mark field.  */
5792       for (section = obfd->sections; section != NULL;
5793            section = section->next)
5794         section->segment_mark = FALSE;
5795
5796       num_segments = elf_elfheader (ibfd)->e_phnum;
5797       for (i = 0, segment = elf_tdata (ibfd)->phdr;
5798            i < num_segments;
5799            i++, segment++)
5800         {
5801           /* PR binutils/3535.  The Solaris linker always sets the p_paddr
5802              and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5803              which severly confuses things, so always regenerate the segment
5804              map in this case.  */
5805           if (segment->p_paddr == 0
5806               && segment->p_memsz == 0
5807               && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
5808             goto rewrite;
5809
5810           for (section = ibfd->sections;
5811                section != NULL; section = section->next)
5812             {
5813               /* We mark the output section so that we know it comes
5814                  from the input BFD.  */
5815               osec = section->output_section;
5816               if (osec)
5817                 osec->segment_mark = TRUE;
5818
5819               /* Check if this section is covered by the segment.  */
5820               this_hdr = &(elf_section_data(section)->this_hdr);
5821               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5822                 {
5823                   /* FIXME: Check if its output section is changed or
5824                      removed.  What else do we need to check?  */
5825                   if (osec == NULL
5826                       || section->flags != osec->flags
5827                       || section->lma != osec->lma
5828                       || section->vma != osec->vma
5829                       || section->size != osec->size
5830                       || section->rawsize != osec->rawsize
5831                       || section->alignment_power != osec->alignment_power)
5832                     goto rewrite;
5833                 }
5834             }
5835         }
5836
5837       /* Check to see if any output section do not come from the
5838          input BFD.  */
5839       for (section = obfd->sections; section != NULL;
5840            section = section->next)
5841         {
5842           if (section->segment_mark == FALSE)
5843             goto rewrite;
5844           else
5845             section->segment_mark = FALSE;
5846         }
5847
5848       return copy_elf_program_header (ibfd, obfd);
5849     }
5850
5851 rewrite:
5852   return rewrite_elf_program_header (ibfd, obfd);
5853 }
5854
5855 /* Initialize private output section information from input section.  */
5856
5857 bfd_boolean
5858 _bfd_elf_init_private_section_data (bfd *ibfd,
5859                                     asection *isec,
5860                                     bfd *obfd,
5861                                     asection *osec,
5862                                     struct bfd_link_info *link_info)
5863
5864 {
5865   Elf_Internal_Shdr *ihdr, *ohdr;
5866   bfd_boolean need_group = link_info == NULL || link_info->relocatable;
5867
5868   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5869       || obfd->xvec->flavour != bfd_target_elf_flavour)
5870     return TRUE;
5871
5872   /* Don't copy the output ELF section type from input if the
5873      output BFD section flags have been set to something different.
5874      elf_fake_sections will set ELF section type based on BFD
5875      section flags.  */
5876   if (elf_section_type (osec) == SHT_NULL
5877       && (osec->flags == isec->flags || !osec->flags))
5878     elf_section_type (osec) = elf_section_type (isec);
5879
5880   /* FIXME: Is this correct for all OS/PROC specific flags?  */
5881   elf_section_flags (osec) |= (elf_section_flags (isec)
5882                                & (SHF_MASKOS | SHF_MASKPROC));
5883
5884   /* Set things up for objcopy and relocatable link.  The output
5885      SHT_GROUP section will have its elf_next_in_group pointing back
5886      to the input group members.  Ignore linker created group section.
5887      See elfNN_ia64_object_p in elfxx-ia64.c.  */
5888   if (need_group)
5889     {
5890       if (elf_sec_group (isec) == NULL
5891           || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
5892         {
5893           if (elf_section_flags (isec) & SHF_GROUP)
5894             elf_section_flags (osec) |= SHF_GROUP;
5895           elf_next_in_group (osec) = elf_next_in_group (isec);
5896           elf_group_name (osec) = elf_group_name (isec);
5897         }
5898     }
5899
5900   ihdr = &elf_section_data (isec)->this_hdr;
5901
5902   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
5903      don't use the output section of the linked-to section since it
5904      may be NULL at this point.  */
5905   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
5906     {
5907       ohdr = &elf_section_data (osec)->this_hdr;
5908       ohdr->sh_flags |= SHF_LINK_ORDER;
5909       elf_linked_to_section (osec) = elf_linked_to_section (isec);
5910     }
5911
5912   osec->use_rela_p = isec->use_rela_p;
5913
5914   return TRUE;
5915 }
5916
5917 /* Copy private section information.  This copies over the entsize
5918    field, and sometimes the info field.  */
5919
5920 bfd_boolean
5921 _bfd_elf_copy_private_section_data (bfd *ibfd,
5922                                     asection *isec,
5923                                     bfd *obfd,
5924                                     asection *osec)
5925 {
5926   Elf_Internal_Shdr *ihdr, *ohdr;
5927
5928   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5929       || obfd->xvec->flavour != bfd_target_elf_flavour)
5930     return TRUE;
5931
5932   ihdr = &elf_section_data (isec)->this_hdr;
5933   ohdr = &elf_section_data (osec)->this_hdr;
5934
5935   ohdr->sh_entsize = ihdr->sh_entsize;
5936
5937   if (ihdr->sh_type == SHT_SYMTAB
5938       || ihdr->sh_type == SHT_DYNSYM
5939       || ihdr->sh_type == SHT_GNU_verneed
5940       || ihdr->sh_type == SHT_GNU_verdef)
5941     ohdr->sh_info = ihdr->sh_info;
5942
5943   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
5944                                              NULL);
5945 }
5946
5947 /* Copy private header information.  */
5948
5949 bfd_boolean
5950 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
5951 {
5952   asection *isec;
5953
5954   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5955       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5956     return TRUE;
5957
5958   /* Copy over private BFD data if it has not already been copied.
5959      This must be done here, rather than in the copy_private_bfd_data
5960      entry point, because the latter is called after the section
5961      contents have been set, which means that the program headers have
5962      already been worked out.  */
5963   if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5964     {
5965       if (! copy_private_bfd_data (ibfd, obfd))
5966         return FALSE;
5967     }
5968
5969   /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
5970      but this might be wrong if we deleted the group section.  */
5971   for (isec = ibfd->sections; isec != NULL; isec = isec->next)
5972     if (elf_section_type (isec) == SHT_GROUP
5973         && isec->output_section == NULL)
5974       {
5975         asection *first = elf_next_in_group (isec);
5976         asection *s = first;
5977         while (s != NULL)
5978           {
5979             if (s->output_section != NULL)
5980               {
5981                 elf_section_flags (s->output_section) &= ~SHF_GROUP;
5982                 elf_group_name (s->output_section) = NULL;
5983               }
5984             s = elf_next_in_group (s);
5985             if (s == first)
5986               break;
5987           }
5988       }
5989
5990   return TRUE;
5991 }
5992
5993 /* Copy private symbol information.  If this symbol is in a section
5994    which we did not map into a BFD section, try to map the section
5995    index correctly.  We use special macro definitions for the mapped
5996    section indices; these definitions are interpreted by the
5997    swap_out_syms function.  */
5998
5999 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6000 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6001 #define MAP_STRTAB    (SHN_HIOS + 3)
6002 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
6003 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6004
6005 bfd_boolean
6006 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6007                                    asymbol *isymarg,
6008                                    bfd *obfd,
6009                                    asymbol *osymarg)
6010 {
6011   elf_symbol_type *isym, *osym;
6012
6013   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6014       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6015     return TRUE;
6016
6017   isym = elf_symbol_from (ibfd, isymarg);
6018   osym = elf_symbol_from (obfd, osymarg);
6019
6020   if (isym != NULL
6021       && osym != NULL
6022       && bfd_is_abs_section (isym->symbol.section))
6023     {
6024       unsigned int shndx;
6025
6026       shndx = isym->internal_elf_sym.st_shndx;
6027       if (shndx == elf_onesymtab (ibfd))
6028         shndx = MAP_ONESYMTAB;
6029       else if (shndx == elf_dynsymtab (ibfd))
6030         shndx = MAP_DYNSYMTAB;
6031       else if (shndx == elf_tdata (ibfd)->strtab_section)
6032         shndx = MAP_STRTAB;
6033       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6034         shndx = MAP_SHSTRTAB;
6035       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6036         shndx = MAP_SYM_SHNDX;
6037       osym->internal_elf_sym.st_shndx = shndx;
6038     }
6039
6040   return TRUE;
6041 }
6042
6043 /* Swap out the symbols.  */
6044
6045 static bfd_boolean
6046 swap_out_syms (bfd *abfd,
6047                struct bfd_strtab_hash **sttp,
6048                int relocatable_p)
6049 {
6050   const struct elf_backend_data *bed;
6051   int symcount;
6052   asymbol **syms;
6053   struct bfd_strtab_hash *stt;
6054   Elf_Internal_Shdr *symtab_hdr;
6055   Elf_Internal_Shdr *symtab_shndx_hdr;
6056   Elf_Internal_Shdr *symstrtab_hdr;
6057   bfd_byte *outbound_syms;
6058   bfd_byte *outbound_shndx;
6059   int idx;
6060   bfd_size_type amt;
6061   bfd_boolean name_local_sections;
6062
6063   if (!elf_map_symbols (abfd))
6064     return FALSE;
6065
6066   /* Dump out the symtabs.  */
6067   stt = _bfd_elf_stringtab_init ();
6068   if (stt == NULL)
6069     return FALSE;
6070
6071   bed = get_elf_backend_data (abfd);
6072   symcount = bfd_get_symcount (abfd);
6073   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6074   symtab_hdr->sh_type = SHT_SYMTAB;
6075   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6076   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6077   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6078   symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
6079
6080   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6081   symstrtab_hdr->sh_type = SHT_STRTAB;
6082
6083   outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
6084   if (outbound_syms == NULL)
6085     {
6086       _bfd_stringtab_free (stt);
6087       return FALSE;
6088     }
6089   symtab_hdr->contents = outbound_syms;
6090
6091   outbound_shndx = NULL;
6092   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6093   if (symtab_shndx_hdr->sh_name != 0)
6094     {
6095       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6096       outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
6097                                     sizeof (Elf_External_Sym_Shndx));
6098       if (outbound_shndx == NULL)
6099         {
6100           _bfd_stringtab_free (stt);
6101           return FALSE;
6102         }
6103
6104       symtab_shndx_hdr->contents = outbound_shndx;
6105       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6106       symtab_shndx_hdr->sh_size = amt;
6107       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6108       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6109     }
6110
6111   /* Now generate the data (for "contents").  */
6112   {
6113     /* Fill in zeroth symbol and swap it out.  */
6114     Elf_Internal_Sym sym;
6115     sym.st_name = 0;
6116     sym.st_value = 0;
6117     sym.st_size = 0;
6118     sym.st_info = 0;
6119     sym.st_other = 0;
6120     sym.st_shndx = SHN_UNDEF;
6121     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6122     outbound_syms += bed->s->sizeof_sym;
6123     if (outbound_shndx != NULL)
6124       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6125   }
6126
6127   name_local_sections
6128     = (bed->elf_backend_name_local_section_symbols
6129        && bed->elf_backend_name_local_section_symbols (abfd));
6130
6131   syms = bfd_get_outsymbols (abfd);
6132   for (idx = 0; idx < symcount; idx++)
6133     {
6134       Elf_Internal_Sym sym;
6135       bfd_vma value = syms[idx]->value;
6136       elf_symbol_type *type_ptr;
6137       flagword flags = syms[idx]->flags;
6138       int type;
6139
6140       if (!name_local_sections
6141           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6142         {
6143           /* Local section symbols have no name.  */
6144           sym.st_name = 0;
6145         }
6146       else
6147         {
6148           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6149                                                             syms[idx]->name,
6150                                                             TRUE, FALSE);
6151           if (sym.st_name == (unsigned long) -1)
6152             {
6153               _bfd_stringtab_free (stt);
6154               return FALSE;
6155             }
6156         }
6157
6158       type_ptr = elf_symbol_from (abfd, syms[idx]);
6159
6160       if ((flags & BSF_SECTION_SYM) == 0
6161           && bfd_is_com_section (syms[idx]->section))
6162         {
6163           /* ELF common symbols put the alignment into the `value' field,
6164              and the size into the `size' field.  This is backwards from
6165              how BFD handles it, so reverse it here.  */
6166           sym.st_size = value;
6167           if (type_ptr == NULL
6168               || type_ptr->internal_elf_sym.st_value == 0)
6169             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6170           else
6171             sym.st_value = type_ptr->internal_elf_sym.st_value;
6172           sym.st_shndx = _bfd_elf_section_from_bfd_section
6173             (abfd, syms[idx]->section);
6174         }
6175       else
6176         {
6177           asection *sec = syms[idx]->section;
6178           int shndx;
6179
6180           if (sec->output_section)
6181             {
6182               value += sec->output_offset;
6183               sec = sec->output_section;
6184             }
6185
6186           /* Don't add in the section vma for relocatable output.  */
6187           if (! relocatable_p)
6188             value += sec->vma;
6189           sym.st_value = value;
6190           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6191
6192           if (bfd_is_abs_section (sec)
6193               && type_ptr != NULL
6194               && type_ptr->internal_elf_sym.st_shndx != 0)
6195             {
6196               /* This symbol is in a real ELF section which we did
6197                  not create as a BFD section.  Undo the mapping done
6198                  by copy_private_symbol_data.  */
6199               shndx = type_ptr->internal_elf_sym.st_shndx;
6200               switch (shndx)
6201                 {
6202                 case MAP_ONESYMTAB:
6203                   shndx = elf_onesymtab (abfd);
6204                   break;
6205                 case MAP_DYNSYMTAB:
6206                   shndx = elf_dynsymtab (abfd);
6207                   break;
6208                 case MAP_STRTAB:
6209                   shndx = elf_tdata (abfd)->strtab_section;
6210                   break;
6211                 case MAP_SHSTRTAB:
6212                   shndx = elf_tdata (abfd)->shstrtab_section;
6213                   break;
6214                 case MAP_SYM_SHNDX:
6215                   shndx = elf_tdata (abfd)->symtab_shndx_section;
6216                   break;
6217                 default:
6218                   break;
6219                 }
6220             }
6221           else
6222             {
6223               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6224
6225               if (shndx == -1)
6226                 {
6227                   asection *sec2;
6228
6229                   /* Writing this would be a hell of a lot easier if
6230                      we had some decent documentation on bfd, and
6231                      knew what to expect of the library, and what to
6232                      demand of applications.  For example, it
6233                      appears that `objcopy' might not set the
6234                      section of a symbol to be a section that is
6235                      actually in the output file.  */
6236                   sec2 = bfd_get_section_by_name (abfd, sec->name);
6237                   if (sec2 == NULL)
6238                     {
6239                       _bfd_error_handler (_("\
6240 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6241                                           syms[idx]->name ? syms[idx]->name : "<Local sym>",
6242                                           sec->name);
6243                       bfd_set_error (bfd_error_invalid_operation);
6244                       _bfd_stringtab_free (stt);
6245                       return FALSE;
6246                     }
6247
6248                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6249                   BFD_ASSERT (shndx != -1);
6250                 }
6251             }
6252
6253           sym.st_shndx = shndx;
6254         }
6255
6256       if ((flags & BSF_THREAD_LOCAL) != 0)
6257         type = STT_TLS;
6258       else if ((flags & BSF_FUNCTION) != 0)
6259         type = STT_FUNC;
6260       else if ((flags & BSF_OBJECT) != 0)
6261         type = STT_OBJECT;
6262       else if ((flags & BSF_RELC) != 0)
6263         type = STT_RELC;
6264       else if ((flags & BSF_SRELC) != 0)
6265         type = STT_SRELC;
6266       else
6267         type = STT_NOTYPE;
6268
6269       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6270         type = STT_TLS;
6271
6272       /* Processor-specific types.  */
6273       if (type_ptr != NULL
6274           && bed->elf_backend_get_symbol_type)
6275         type = ((*bed->elf_backend_get_symbol_type)
6276                 (&type_ptr->internal_elf_sym, type));
6277
6278       if (flags & BSF_SECTION_SYM)
6279         {
6280           if (flags & BSF_GLOBAL)
6281             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6282           else
6283             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6284         }
6285       else if (bfd_is_com_section (syms[idx]->section))
6286         sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6287       else if (bfd_is_und_section (syms[idx]->section))
6288         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6289                                     ? STB_WEAK
6290                                     : STB_GLOBAL),
6291                                    type);
6292       else if (flags & BSF_FILE)
6293         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6294       else
6295         {
6296           int bind = STB_LOCAL;
6297
6298           if (flags & BSF_LOCAL)
6299             bind = STB_LOCAL;
6300           else if (flags & BSF_WEAK)
6301             bind = STB_WEAK;
6302           else if (flags & BSF_GLOBAL)
6303             bind = STB_GLOBAL;
6304
6305           sym.st_info = ELF_ST_INFO (bind, type);
6306         }
6307
6308       if (type_ptr != NULL)
6309         sym.st_other = type_ptr->internal_elf_sym.st_other;
6310       else
6311         sym.st_other = 0;
6312
6313       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6314       outbound_syms += bed->s->sizeof_sym;
6315       if (outbound_shndx != NULL)
6316         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6317     }
6318
6319   *sttp = stt;
6320   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6321   symstrtab_hdr->sh_type = SHT_STRTAB;
6322
6323   symstrtab_hdr->sh_flags = 0;
6324   symstrtab_hdr->sh_addr = 0;
6325   symstrtab_hdr->sh_entsize = 0;
6326   symstrtab_hdr->sh_link = 0;
6327   symstrtab_hdr->sh_info = 0;
6328   symstrtab_hdr->sh_addralign = 1;
6329
6330   return TRUE;
6331 }
6332
6333 /* Return the number of bytes required to hold the symtab vector.
6334
6335    Note that we base it on the count plus 1, since we will null terminate
6336    the vector allocated based on this size.  However, the ELF symbol table
6337    always has a dummy entry as symbol #0, so it ends up even.  */
6338
6339 long
6340 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6341 {
6342   long symcount;
6343   long symtab_size;
6344   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6345
6346   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6347   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6348   if (symcount > 0)
6349     symtab_size -= sizeof (asymbol *);
6350
6351   return symtab_size;
6352 }
6353
6354 long
6355 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6356 {
6357   long symcount;
6358   long symtab_size;
6359   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6360
6361   if (elf_dynsymtab (abfd) == 0)
6362     {
6363       bfd_set_error (bfd_error_invalid_operation);
6364       return -1;
6365     }
6366
6367   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6368   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6369   if (symcount > 0)
6370     symtab_size -= sizeof (asymbol *);
6371
6372   return symtab_size;
6373 }
6374
6375 long
6376 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6377                                 sec_ptr asect)
6378 {
6379   return (asect->reloc_count + 1) * sizeof (arelent *);
6380 }
6381
6382 /* Canonicalize the relocs.  */
6383
6384 long
6385 _bfd_elf_canonicalize_reloc (bfd *abfd,
6386                              sec_ptr section,
6387                              arelent **relptr,
6388                              asymbol **symbols)
6389 {
6390   arelent *tblptr;
6391   unsigned int i;
6392   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6393
6394   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6395     return -1;
6396
6397   tblptr = section->relocation;
6398   for (i = 0; i < section->reloc_count; i++)
6399     *relptr++ = tblptr++;
6400
6401   *relptr = NULL;
6402
6403   return section->reloc_count;
6404 }
6405
6406 long
6407 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6408 {
6409   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6410   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6411
6412   if (symcount >= 0)
6413     bfd_get_symcount (abfd) = symcount;
6414   return symcount;
6415 }
6416
6417 long
6418 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6419                                       asymbol **allocation)
6420 {
6421   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6422   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6423
6424   if (symcount >= 0)
6425     bfd_get_dynamic_symcount (abfd) = symcount;
6426   return symcount;
6427 }
6428
6429 /* Return the size required for the dynamic reloc entries.  Any loadable
6430    section that was actually installed in the BFD, and has type SHT_REL
6431    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6432    dynamic reloc section.  */
6433
6434 long
6435 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6436 {
6437   long ret;
6438   asection *s;
6439
6440   if (elf_dynsymtab (abfd) == 0)
6441     {
6442       bfd_set_error (bfd_error_invalid_operation);
6443       return -1;
6444     }
6445
6446   ret = sizeof (arelent *);
6447   for (s = abfd->sections; s != NULL; s = s->next)
6448     if ((s->flags & SEC_LOAD) != 0
6449         && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6450         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6451             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6452       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6453               * sizeof (arelent *));
6454
6455   return ret;
6456 }
6457
6458 /* Canonicalize the dynamic relocation entries.  Note that we return the
6459    dynamic relocations as a single block, although they are actually
6460    associated with particular sections; the interface, which was
6461    designed for SunOS style shared libraries, expects that there is only
6462    one set of dynamic relocs.  Any loadable section that was actually
6463    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6464    dynamic symbol table, is considered to be a dynamic reloc section.  */
6465
6466 long
6467 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6468                                      arelent **storage,
6469                                      asymbol **syms)
6470 {
6471   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6472   asection *s;
6473   long ret;
6474
6475   if (elf_dynsymtab (abfd) == 0)
6476     {
6477       bfd_set_error (bfd_error_invalid_operation);
6478       return -1;
6479     }
6480
6481   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6482   ret = 0;
6483   for (s = abfd->sections; s != NULL; s = s->next)
6484     {
6485       if ((s->flags & SEC_LOAD) != 0
6486           && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6487           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6488               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6489         {
6490           arelent *p;
6491           long count, i;
6492
6493           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6494             return -1;
6495           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6496           p = s->relocation;
6497           for (i = 0; i < count; i++)
6498             *storage++ = p++;
6499           ret += count;
6500         }
6501     }
6502
6503   *storage = NULL;
6504
6505   return ret;
6506 }
6507 \f
6508 /* Read in the version information.  */
6509
6510 bfd_boolean
6511 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6512 {
6513   bfd_byte *contents = NULL;
6514   unsigned int freeidx = 0;
6515
6516   if (elf_dynverref (abfd) != 0)
6517     {
6518       Elf_Internal_Shdr *hdr;
6519       Elf_External_Verneed *everneed;
6520       Elf_Internal_Verneed *iverneed;
6521       unsigned int i;
6522       bfd_byte *contents_end;
6523
6524       hdr = &elf_tdata (abfd)->dynverref_hdr;
6525
6526       elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6527                                               sizeof (Elf_Internal_Verneed));
6528       if (elf_tdata (abfd)->verref == NULL)
6529         goto error_return;
6530
6531       elf_tdata (abfd)->cverrefs = hdr->sh_info;
6532
6533       contents = bfd_malloc (hdr->sh_size);
6534       if (contents == NULL)
6535         {
6536 error_return_verref:
6537           elf_tdata (abfd)->verref = NULL;
6538           elf_tdata (abfd)->cverrefs = 0;
6539           goto error_return;
6540         }
6541       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6542           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6543         goto error_return_verref;
6544
6545       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6546         goto error_return_verref;
6547
6548       BFD_ASSERT (sizeof (Elf_External_Verneed)
6549                   == sizeof (Elf_External_Vernaux));
6550       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6551       everneed = (Elf_External_Verneed *) contents;
6552       iverneed = elf_tdata (abfd)->verref;
6553       for (i = 0; i < hdr->sh_info; i++, iverneed++)
6554         {
6555           Elf_External_Vernaux *evernaux;
6556           Elf_Internal_Vernaux *ivernaux;
6557           unsigned int j;
6558
6559           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6560
6561           iverneed->vn_bfd = abfd;
6562
6563           iverneed->vn_filename =
6564             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6565                                              iverneed->vn_file);
6566           if (iverneed->vn_filename == NULL)
6567             goto error_return_verref;
6568
6569           if (iverneed->vn_cnt == 0)
6570             iverneed->vn_auxptr = NULL;
6571           else
6572             {
6573               iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6574                                                 sizeof (Elf_Internal_Vernaux));
6575               if (iverneed->vn_auxptr == NULL)
6576                 goto error_return_verref;
6577             }
6578
6579           if (iverneed->vn_aux
6580               > (size_t) (contents_end - (bfd_byte *) everneed))
6581             goto error_return_verref;
6582
6583           evernaux = ((Elf_External_Vernaux *)
6584                       ((bfd_byte *) everneed + iverneed->vn_aux));
6585           ivernaux = iverneed->vn_auxptr;
6586           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6587             {
6588               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6589
6590               ivernaux->vna_nodename =
6591                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6592                                                  ivernaux->vna_name);
6593               if (ivernaux->vna_nodename == NULL)
6594                 goto error_return_verref;
6595
6596               if (j + 1 < iverneed->vn_cnt)
6597                 ivernaux->vna_nextptr = ivernaux + 1;
6598               else
6599                 ivernaux->vna_nextptr = NULL;
6600
6601               if (ivernaux->vna_next
6602                   > (size_t) (contents_end - (bfd_byte *) evernaux))
6603                 goto error_return_verref;
6604
6605               evernaux = ((Elf_External_Vernaux *)
6606                           ((bfd_byte *) evernaux + ivernaux->vna_next));
6607
6608               if (ivernaux->vna_other > freeidx)
6609                 freeidx = ivernaux->vna_other;
6610             }
6611
6612           if (i + 1 < hdr->sh_info)
6613             iverneed->vn_nextref = iverneed + 1;
6614           else
6615             iverneed->vn_nextref = NULL;
6616
6617           if (iverneed->vn_next
6618               > (size_t) (contents_end - (bfd_byte *) everneed))
6619             goto error_return_verref;
6620
6621           everneed = ((Elf_External_Verneed *)
6622                       ((bfd_byte *) everneed + iverneed->vn_next));
6623         }
6624
6625       free (contents);
6626       contents = NULL;
6627     }
6628
6629   if (elf_dynverdef (abfd) != 0)
6630     {
6631       Elf_Internal_Shdr *hdr;
6632       Elf_External_Verdef *everdef;
6633       Elf_Internal_Verdef *iverdef;
6634       Elf_Internal_Verdef *iverdefarr;
6635       Elf_Internal_Verdef iverdefmem;
6636       unsigned int i;
6637       unsigned int maxidx;
6638       bfd_byte *contents_end_def, *contents_end_aux;
6639
6640       hdr = &elf_tdata (abfd)->dynverdef_hdr;
6641
6642       contents = bfd_malloc (hdr->sh_size);
6643       if (contents == NULL)
6644         goto error_return;
6645       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6646           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6647         goto error_return;
6648
6649       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6650         goto error_return;
6651
6652       BFD_ASSERT (sizeof (Elf_External_Verdef)
6653                   >= sizeof (Elf_External_Verdaux));
6654       contents_end_def = contents + hdr->sh_size
6655                          - sizeof (Elf_External_Verdef);
6656       contents_end_aux = contents + hdr->sh_size
6657                          - sizeof (Elf_External_Verdaux);
6658
6659       /* We know the number of entries in the section but not the maximum
6660          index.  Therefore we have to run through all entries and find
6661          the maximum.  */
6662       everdef = (Elf_External_Verdef *) contents;
6663       maxidx = 0;
6664       for (i = 0; i < hdr->sh_info; ++i)
6665         {
6666           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6667
6668           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6669             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6670
6671           if (iverdefmem.vd_next
6672               > (size_t) (contents_end_def - (bfd_byte *) everdef))
6673             goto error_return;
6674
6675           everdef = ((Elf_External_Verdef *)
6676                      ((bfd_byte *) everdef + iverdefmem.vd_next));
6677         }
6678
6679       if (default_imported_symver)
6680         {
6681           if (freeidx > maxidx)
6682             maxidx = ++freeidx;
6683           else
6684             freeidx = ++maxidx;
6685         }
6686       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6687                                               sizeof (Elf_Internal_Verdef));
6688       if (elf_tdata (abfd)->verdef == NULL)
6689         goto error_return;
6690
6691       elf_tdata (abfd)->cverdefs = maxidx;
6692
6693       everdef = (Elf_External_Verdef *) contents;
6694       iverdefarr = elf_tdata (abfd)->verdef;
6695       for (i = 0; i < hdr->sh_info; i++)
6696         {
6697           Elf_External_Verdaux *everdaux;
6698           Elf_Internal_Verdaux *iverdaux;
6699           unsigned int j;
6700
6701           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6702
6703           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6704             {
6705 error_return_verdef:
6706               elf_tdata (abfd)->verdef = NULL;
6707               elf_tdata (abfd)->cverdefs = 0;
6708               goto error_return;
6709             }
6710
6711           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6712           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6713
6714           iverdef->vd_bfd = abfd;
6715
6716           if (iverdef->vd_cnt == 0)
6717             iverdef->vd_auxptr = NULL;
6718           else
6719             {
6720               iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6721                                                sizeof (Elf_Internal_Verdaux));
6722               if (iverdef->vd_auxptr == NULL)
6723                 goto error_return_verdef;
6724             }
6725
6726           if (iverdef->vd_aux
6727               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6728             goto error_return_verdef;
6729
6730           everdaux = ((Elf_External_Verdaux *)
6731                       ((bfd_byte *) everdef + iverdef->vd_aux));
6732           iverdaux = iverdef->vd_auxptr;
6733           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6734             {
6735               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6736
6737               iverdaux->vda_nodename =
6738                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6739                                                  iverdaux->vda_name);
6740               if (iverdaux->vda_nodename == NULL)
6741                 goto error_return_verdef;
6742
6743               if (j + 1 < iverdef->vd_cnt)
6744                 iverdaux->vda_nextptr = iverdaux + 1;
6745               else
6746                 iverdaux->vda_nextptr = NULL;
6747
6748               if (iverdaux->vda_next
6749                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6750                 goto error_return_verdef;
6751
6752               everdaux = ((Elf_External_Verdaux *)
6753                           ((bfd_byte *) everdaux + iverdaux->vda_next));
6754             }
6755
6756           if (iverdef->vd_cnt)
6757             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6758
6759           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
6760             iverdef->vd_nextdef = iverdef + 1;
6761           else
6762             iverdef->vd_nextdef = NULL;
6763
6764           everdef = ((Elf_External_Verdef *)
6765                      ((bfd_byte *) everdef + iverdef->vd_next));
6766         }
6767
6768       free (contents);
6769       contents = NULL;
6770     }
6771   else if (default_imported_symver)
6772     {
6773       if (freeidx < 3)
6774         freeidx = 3;
6775       else
6776         freeidx++;
6777
6778       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6779                                               sizeof (Elf_Internal_Verdef));
6780       if (elf_tdata (abfd)->verdef == NULL)
6781         goto error_return;
6782
6783       elf_tdata (abfd)->cverdefs = freeidx;
6784     }
6785
6786   /* Create a default version based on the soname.  */
6787   if (default_imported_symver)
6788     {
6789       Elf_Internal_Verdef *iverdef;
6790       Elf_Internal_Verdaux *iverdaux;
6791
6792       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6793
6794       iverdef->vd_version = VER_DEF_CURRENT;
6795       iverdef->vd_flags = 0;
6796       iverdef->vd_ndx = freeidx;
6797       iverdef->vd_cnt = 1;
6798
6799       iverdef->vd_bfd = abfd;
6800
6801       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6802       if (iverdef->vd_nodename == NULL)
6803         goto error_return_verdef;
6804       iverdef->vd_nextdef = NULL;
6805       iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6806       if (iverdef->vd_auxptr == NULL)
6807         goto error_return_verdef;
6808
6809       iverdaux = iverdef->vd_auxptr;
6810       iverdaux->vda_nodename = iverdef->vd_nodename;
6811       iverdaux->vda_nextptr = NULL;
6812     }
6813
6814   return TRUE;
6815
6816  error_return:
6817   if (contents != NULL)
6818     free (contents);
6819   return FALSE;
6820 }
6821 \f
6822 asymbol *
6823 _bfd_elf_make_empty_symbol (bfd *abfd)
6824 {
6825   elf_symbol_type *newsym;
6826   bfd_size_type amt = sizeof (elf_symbol_type);
6827
6828   newsym = bfd_zalloc (abfd, amt);
6829   if (!newsym)
6830     return NULL;
6831   else
6832     {
6833       newsym->symbol.the_bfd = abfd;
6834       return &newsym->symbol;
6835     }
6836 }
6837
6838 void
6839 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6840                           asymbol *symbol,
6841                           symbol_info *ret)
6842 {
6843   bfd_symbol_info (symbol, ret);
6844 }
6845
6846 /* Return whether a symbol name implies a local symbol.  Most targets
6847    use this function for the is_local_label_name entry point, but some
6848    override it.  */
6849
6850 bfd_boolean
6851 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6852                               const char *name)
6853 {
6854   /* Normal local symbols start with ``.L''.  */
6855   if (name[0] == '.' && name[1] == 'L')
6856     return TRUE;
6857
6858   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6859      DWARF debugging symbols starting with ``..''.  */
6860   if (name[0] == '.' && name[1] == '.')
6861     return TRUE;
6862
6863   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6864      emitting DWARF debugging output.  I suspect this is actually a
6865      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6866      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6867      underscore to be emitted on some ELF targets).  For ease of use,
6868      we treat such symbols as local.  */
6869   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
6870     return TRUE;
6871
6872   return FALSE;
6873 }
6874
6875 alent *
6876 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6877                      asymbol *symbol ATTRIBUTE_UNUSED)
6878 {
6879   abort ();
6880   return NULL;
6881 }
6882
6883 bfd_boolean
6884 _bfd_elf_set_arch_mach (bfd *abfd,
6885                         enum bfd_architecture arch,
6886                         unsigned long machine)
6887 {
6888   /* If this isn't the right architecture for this backend, and this
6889      isn't the generic backend, fail.  */
6890   if (arch != get_elf_backend_data (abfd)->arch
6891       && arch != bfd_arch_unknown
6892       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
6893     return FALSE;
6894
6895   return bfd_default_set_arch_mach (abfd, arch, machine);
6896 }
6897
6898 /* Find the function to a particular section and offset,
6899    for error reporting.  */
6900
6901 static bfd_boolean
6902 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6903                    asection *section,
6904                    asymbol **symbols,
6905                    bfd_vma offset,
6906                    const char **filename_ptr,
6907                    const char **functionname_ptr)
6908 {
6909   const char *filename;
6910   asymbol *func, *file;
6911   bfd_vma low_func;
6912   asymbol **p;
6913   /* ??? Given multiple file symbols, it is impossible to reliably
6914      choose the right file name for global symbols.  File symbols are
6915      local symbols, and thus all file symbols must sort before any
6916      global symbols.  The ELF spec may be interpreted to say that a
6917      file symbol must sort before other local symbols, but currently
6918      ld -r doesn't do this.  So, for ld -r output, it is possible to
6919      make a better choice of file name for local symbols by ignoring
6920      file symbols appearing after a given local symbol.  */
6921   enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
6922
6923   filename = NULL;
6924   func = NULL;
6925   file = NULL;
6926   low_func = 0;
6927   state = nothing_seen;
6928
6929   for (p = symbols; *p != NULL; p++)
6930     {
6931       elf_symbol_type *q;
6932
6933       q = (elf_symbol_type *) *p;
6934
6935       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6936         {
6937         default:
6938           break;
6939         case STT_FILE:
6940           file = &q->symbol;
6941           if (state == symbol_seen)
6942             state = file_after_symbol_seen;
6943           continue;
6944         case STT_NOTYPE:
6945         case STT_FUNC:
6946           if (bfd_get_section (&q->symbol) == section
6947               && q->symbol.value >= low_func
6948               && q->symbol.value <= offset)
6949             {
6950               func = (asymbol *) q;
6951               low_func = q->symbol.value;
6952               filename = NULL;
6953               if (file != NULL
6954                   && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
6955                       || state != file_after_symbol_seen))
6956                 filename = bfd_asymbol_name (file);
6957             }
6958           break;
6959         }
6960       if (state == nothing_seen)
6961         state = symbol_seen;
6962     }
6963
6964   if (func == NULL)
6965     return FALSE;
6966
6967   if (filename_ptr)
6968     *filename_ptr = filename;
6969   if (functionname_ptr)
6970     *functionname_ptr = bfd_asymbol_name (func);
6971
6972   return TRUE;
6973 }
6974
6975 /* Find the nearest line to a particular section and offset,
6976    for error reporting.  */
6977
6978 bfd_boolean
6979 _bfd_elf_find_nearest_line (bfd *abfd,
6980                             asection *section,
6981                             asymbol **symbols,
6982                             bfd_vma offset,
6983                             const char **filename_ptr,
6984                             const char **functionname_ptr,
6985                             unsigned int *line_ptr)
6986 {
6987   bfd_boolean found;
6988
6989   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6990                                      filename_ptr, functionname_ptr,
6991                                      line_ptr))
6992     {
6993       if (!*functionname_ptr)
6994         elf_find_function (abfd, section, symbols, offset,
6995                            *filename_ptr ? NULL : filename_ptr,
6996                            functionname_ptr);
6997
6998       return TRUE;
6999     }
7000
7001   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7002                                      filename_ptr, functionname_ptr,
7003                                      line_ptr, 0,
7004                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7005     {
7006       if (!*functionname_ptr)
7007         elf_find_function (abfd, section, symbols, offset,
7008                            *filename_ptr ? NULL : filename_ptr,
7009                            functionname_ptr);
7010
7011       return TRUE;
7012     }
7013
7014   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7015                                              &found, filename_ptr,
7016                                              functionname_ptr, line_ptr,
7017                                              &elf_tdata (abfd)->line_info))
7018     return FALSE;
7019   if (found && (*functionname_ptr || *line_ptr))
7020     return TRUE;
7021
7022   if (symbols == NULL)
7023     return FALSE;
7024
7025   if (! elf_find_function (abfd, section, symbols, offset,
7026                            filename_ptr, functionname_ptr))
7027     return FALSE;
7028
7029   *line_ptr = 0;
7030   return TRUE;
7031 }
7032
7033 /* Find the line for a symbol.  */
7034
7035 bfd_boolean
7036 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7037                     const char **filename_ptr, unsigned int *line_ptr)
7038 {
7039   return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7040                                 filename_ptr, line_ptr, 0,
7041                                 &elf_tdata (abfd)->dwarf2_find_line_info);
7042 }
7043
7044 /* After a call to bfd_find_nearest_line, successive calls to
7045    bfd_find_inliner_info can be used to get source information about
7046    each level of function inlining that terminated at the address
7047    passed to bfd_find_nearest_line.  Currently this is only supported
7048    for DWARF2 with appropriate DWARF3 extensions. */
7049
7050 bfd_boolean
7051 _bfd_elf_find_inliner_info (bfd *abfd,
7052                             const char **filename_ptr,
7053                             const char **functionname_ptr,
7054                             unsigned int *line_ptr)
7055 {
7056   bfd_boolean found;
7057   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7058                                          functionname_ptr, line_ptr,
7059                                          & elf_tdata (abfd)->dwarf2_find_line_info);
7060   return found;
7061 }
7062
7063 int
7064 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7065 {
7066   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7067   int ret = bed->s->sizeof_ehdr;
7068
7069   if (!info->relocatable)
7070     {
7071       bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7072
7073       if (phdr_size == (bfd_size_type) -1)
7074         {
7075           struct elf_segment_map *m;
7076
7077           phdr_size = 0;
7078           for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7079             phdr_size += bed->s->sizeof_phdr;
7080
7081           if (phdr_size == 0)
7082             phdr_size = get_program_header_size (abfd, info);
7083         }
7084
7085       elf_tdata (abfd)->program_header_size = phdr_size;
7086       ret += phdr_size;
7087     }
7088
7089   return ret;
7090 }
7091
7092 bfd_boolean
7093 _bfd_elf_set_section_contents (bfd *abfd,
7094                                sec_ptr section,
7095                                const void *location,
7096                                file_ptr offset,
7097                                bfd_size_type count)
7098 {
7099   Elf_Internal_Shdr *hdr;
7100   bfd_signed_vma pos;
7101
7102   if (! abfd->output_has_begun
7103       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7104     return FALSE;
7105
7106   hdr = &elf_section_data (section)->this_hdr;
7107   pos = hdr->sh_offset + offset;
7108   if (bfd_seek (abfd, pos, SEEK_SET) != 0
7109       || bfd_bwrite (location, count, abfd) != count)
7110     return FALSE;
7111
7112   return TRUE;
7113 }
7114
7115 void
7116 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7117                            arelent *cache_ptr ATTRIBUTE_UNUSED,
7118                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7119 {
7120   abort ();
7121 }
7122
7123 /* Try to convert a non-ELF reloc into an ELF one.  */
7124
7125 bfd_boolean
7126 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7127 {
7128   /* Check whether we really have an ELF howto.  */
7129
7130   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7131     {
7132       bfd_reloc_code_real_type code;
7133       reloc_howto_type *howto;
7134
7135       /* Alien reloc: Try to determine its type to replace it with an
7136          equivalent ELF reloc.  */
7137
7138       if (areloc->howto->pc_relative)
7139         {
7140           switch (areloc->howto->bitsize)
7141             {
7142             case 8:
7143               code = BFD_RELOC_8_PCREL;
7144               break;
7145             case 12:
7146               code = BFD_RELOC_12_PCREL;
7147               break;
7148             case 16:
7149               code = BFD_RELOC_16_PCREL;
7150               break;
7151             case 24:
7152               code = BFD_RELOC_24_PCREL;
7153               break;
7154             case 32:
7155               code = BFD_RELOC_32_PCREL;
7156               break;
7157             case 64:
7158               code = BFD_RELOC_64_PCREL;
7159               break;
7160             default:
7161               goto fail;
7162             }
7163
7164           howto = bfd_reloc_type_lookup (abfd, code);
7165
7166           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7167             {
7168               if (howto->pcrel_offset)
7169                 areloc->addend += areloc->address;
7170               else
7171                 areloc->addend -= areloc->address; /* addend is unsigned!! */
7172             }
7173         }
7174       else
7175         {
7176           switch (areloc->howto->bitsize)
7177             {
7178             case 8:
7179               code = BFD_RELOC_8;
7180               break;
7181             case 14:
7182               code = BFD_RELOC_14;
7183               break;
7184             case 16:
7185               code = BFD_RELOC_16;
7186               break;
7187             case 26:
7188               code = BFD_RELOC_26;
7189               break;
7190             case 32:
7191               code = BFD_RELOC_32;
7192               break;
7193             case 64:
7194               code = BFD_RELOC_64;
7195               break;
7196             default:
7197               goto fail;
7198             }
7199
7200           howto = bfd_reloc_type_lookup (abfd, code);
7201         }
7202
7203       if (howto)
7204         areloc->howto = howto;
7205       else
7206         goto fail;
7207     }
7208
7209   return TRUE;
7210
7211  fail:
7212   (*_bfd_error_handler)
7213     (_("%B: unsupported relocation type %s"),
7214      abfd, areloc->howto->name);
7215   bfd_set_error (bfd_error_bad_value);
7216   return FALSE;
7217 }
7218
7219 bfd_boolean
7220 _bfd_elf_close_and_cleanup (bfd *abfd)
7221 {
7222   if (bfd_get_format (abfd) == bfd_object)
7223     {
7224       if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
7225         _bfd_elf_strtab_free (elf_shstrtab (abfd));
7226       _bfd_dwarf2_cleanup_debug_info (abfd);
7227     }
7228
7229   return _bfd_generic_close_and_cleanup (abfd);
7230 }
7231
7232 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7233    in the relocation's offset.  Thus we cannot allow any sort of sanity
7234    range-checking to interfere.  There is nothing else to do in processing
7235    this reloc.  */
7236
7237 bfd_reloc_status_type
7238 _bfd_elf_rel_vtable_reloc_fn
7239   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7240    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7241    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7242    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7243 {
7244   return bfd_reloc_ok;
7245 }
7246 \f
7247 /* Elf core file support.  Much of this only works on native
7248    toolchains, since we rely on knowing the
7249    machine-dependent procfs structure in order to pick
7250    out details about the corefile.  */
7251
7252 #ifdef HAVE_SYS_PROCFS_H
7253 # include <sys/procfs.h>
7254 #endif
7255
7256 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
7257
7258 static int
7259 elfcore_make_pid (bfd *abfd)
7260 {
7261   return ((elf_tdata (abfd)->core_lwpid << 16)
7262           + (elf_tdata (abfd)->core_pid));
7263 }
7264
7265 /* If there isn't a section called NAME, make one, using
7266    data from SECT.  Note, this function will generate a
7267    reference to NAME, so you shouldn't deallocate or
7268    overwrite it.  */
7269
7270 static bfd_boolean
7271 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7272 {
7273   asection *sect2;
7274
7275   if (bfd_get_section_by_name (abfd, name) != NULL)
7276     return TRUE;
7277
7278   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7279   if (sect2 == NULL)
7280     return FALSE;
7281
7282   sect2->size = sect->size;
7283   sect2->filepos = sect->filepos;
7284   sect2->alignment_power = sect->alignment_power;
7285   return TRUE;
7286 }
7287
7288 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
7289    actually creates up to two pseudosections:
7290    - For the single-threaded case, a section named NAME, unless
7291      such a section already exists.
7292    - For the multi-threaded case, a section named "NAME/PID", where
7293      PID is elfcore_make_pid (abfd).
7294    Both pseudosections have identical contents. */
7295 bfd_boolean
7296 _bfd_elfcore_make_pseudosection (bfd *abfd,
7297                                  char *name,
7298                                  size_t size,
7299                                  ufile_ptr filepos)
7300 {
7301   char buf[100];
7302   char *threaded_name;
7303   size_t len;
7304   asection *sect;
7305
7306   /* Build the section name.  */
7307
7308   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7309   len = strlen (buf) + 1;
7310   threaded_name = bfd_alloc (abfd, len);
7311   if (threaded_name == NULL)
7312     return FALSE;
7313   memcpy (threaded_name, buf, len);
7314
7315   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7316                                              SEC_HAS_CONTENTS);
7317   if (sect == NULL)
7318     return FALSE;
7319   sect->size = size;
7320   sect->filepos = filepos;
7321   sect->alignment_power = 2;
7322
7323   return elfcore_maybe_make_sect (abfd, name, sect);
7324 }
7325
7326 /* prstatus_t exists on:
7327      solaris 2.5+
7328      linux 2.[01] + glibc
7329      unixware 4.2
7330 */
7331
7332 #if defined (HAVE_PRSTATUS_T)
7333
7334 static bfd_boolean
7335 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7336 {
7337   size_t size;
7338   int offset;
7339
7340   if (note->descsz == sizeof (prstatus_t))
7341     {
7342       prstatus_t prstat;
7343
7344       size = sizeof (prstat.pr_reg);
7345       offset   = offsetof (prstatus_t, pr_reg);
7346       memcpy (&prstat, note->descdata, sizeof (prstat));
7347
7348       /* Do not overwrite the core signal if it
7349          has already been set by another thread.  */
7350       if (elf_tdata (abfd)->core_signal == 0)
7351         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7352       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7353
7354       /* pr_who exists on:
7355          solaris 2.5+
7356          unixware 4.2
7357          pr_who doesn't exist on:
7358          linux 2.[01]
7359          */
7360 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7361       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7362 #endif
7363     }
7364 #if defined (HAVE_PRSTATUS32_T)
7365   else if (note->descsz == sizeof (prstatus32_t))
7366     {
7367       /* 64-bit host, 32-bit corefile */
7368       prstatus32_t prstat;
7369
7370       size = sizeof (prstat.pr_reg);
7371       offset   = offsetof (prstatus32_t, pr_reg);
7372       memcpy (&prstat, note->descdata, sizeof (prstat));
7373
7374       /* Do not overwrite the core signal if it
7375          has already been set by another thread.  */
7376       if (elf_tdata (abfd)->core_signal == 0)
7377         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7378       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7379
7380       /* pr_who exists on:
7381          solaris 2.5+
7382          unixware 4.2
7383          pr_who doesn't exist on:
7384          linux 2.[01]
7385          */
7386 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7387       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7388 #endif
7389     }
7390 #endif /* HAVE_PRSTATUS32_T */
7391   else
7392     {
7393       /* Fail - we don't know how to handle any other
7394          note size (ie. data object type).  */
7395       return TRUE;
7396     }
7397
7398   /* Make a ".reg/999" section and a ".reg" section.  */
7399   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7400                                           size, note->descpos + offset);
7401 }
7402 #endif /* defined (HAVE_PRSTATUS_T) */
7403
7404 /* Create a pseudosection containing the exact contents of NOTE.  */
7405 static bfd_boolean
7406 elfcore_make_note_pseudosection (bfd *abfd,
7407                                  char *name,
7408                                  Elf_Internal_Note *note)
7409 {
7410   return _bfd_elfcore_make_pseudosection (abfd, name,
7411                                           note->descsz, note->descpos);
7412 }
7413
7414 /* There isn't a consistent prfpregset_t across platforms,
7415    but it doesn't matter, because we don't have to pick this
7416    data structure apart.  */
7417
7418 static bfd_boolean
7419 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7420 {
7421   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7422 }
7423
7424 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7425    type of 5 (NT_PRXFPREG).  Just include the whole note's contents
7426    literally.  */
7427
7428 static bfd_boolean
7429 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7430 {
7431   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7432 }
7433
7434 #if defined (HAVE_PRPSINFO_T)
7435 typedef prpsinfo_t   elfcore_psinfo_t;
7436 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
7437 typedef prpsinfo32_t elfcore_psinfo32_t;
7438 #endif
7439 #endif
7440
7441 #if defined (HAVE_PSINFO_T)
7442 typedef psinfo_t   elfcore_psinfo_t;
7443 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
7444 typedef psinfo32_t elfcore_psinfo32_t;
7445 #endif
7446 #endif
7447
7448 /* return a malloc'ed copy of a string at START which is at
7449    most MAX bytes long, possibly without a terminating '\0'.
7450    the copy will always have a terminating '\0'.  */
7451
7452 char *
7453 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7454 {
7455   char *dups;
7456   char *end = memchr (start, '\0', max);
7457   size_t len;
7458
7459   if (end == NULL)
7460     len = max;
7461   else
7462     len = end - start;
7463
7464   dups = bfd_alloc (abfd, len + 1);
7465   if (dups == NULL)
7466     return NULL;
7467
7468   memcpy (dups, start, len);
7469   dups[len] = '\0';
7470
7471   return dups;
7472 }
7473
7474 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7475 static bfd_boolean
7476 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7477 {
7478   if (note->descsz == sizeof (elfcore_psinfo_t))
7479     {
7480       elfcore_psinfo_t psinfo;
7481
7482       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7483
7484       elf_tdata (abfd)->core_program
7485         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7486                                 sizeof (psinfo.pr_fname));
7487
7488       elf_tdata (abfd)->core_command
7489         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7490                                 sizeof (psinfo.pr_psargs));
7491     }
7492 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7493   else if (note->descsz == sizeof (elfcore_psinfo32_t))
7494     {
7495       /* 64-bit host, 32-bit corefile */
7496       elfcore_psinfo32_t psinfo;
7497
7498       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7499
7500       elf_tdata (abfd)->core_program
7501         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7502                                 sizeof (psinfo.pr_fname));
7503
7504       elf_tdata (abfd)->core_command
7505         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7506                                 sizeof (psinfo.pr_psargs));
7507     }
7508 #endif
7509
7510   else
7511     {
7512       /* Fail - we don't know how to handle any other
7513          note size (ie. data object type).  */
7514       return TRUE;
7515     }
7516
7517   /* Note that for some reason, a spurious space is tacked
7518      onto the end of the args in some (at least one anyway)
7519      implementations, so strip it off if it exists.  */
7520
7521   {
7522     char *command = elf_tdata (abfd)->core_command;
7523     int n = strlen (command);
7524
7525     if (0 < n && command[n - 1] == ' ')
7526       command[n - 1] = '\0';
7527   }
7528
7529   return TRUE;
7530 }
7531 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7532
7533 #if defined (HAVE_PSTATUS_T)
7534 static bfd_boolean
7535 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7536 {
7537   if (note->descsz == sizeof (pstatus_t)
7538 #if defined (HAVE_PXSTATUS_T)
7539       || note->descsz == sizeof (pxstatus_t)
7540 #endif
7541       )
7542     {
7543       pstatus_t pstat;
7544
7545       memcpy (&pstat, note->descdata, sizeof (pstat));
7546
7547       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7548     }
7549 #if defined (HAVE_PSTATUS32_T)
7550   else if (note->descsz == sizeof (pstatus32_t))
7551     {
7552       /* 64-bit host, 32-bit corefile */
7553       pstatus32_t pstat;
7554
7555       memcpy (&pstat, note->descdata, sizeof (pstat));
7556
7557       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7558     }
7559 #endif
7560   /* Could grab some more details from the "representative"
7561      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7562      NT_LWPSTATUS note, presumably.  */
7563
7564   return TRUE;
7565 }
7566 #endif /* defined (HAVE_PSTATUS_T) */
7567
7568 #if defined (HAVE_LWPSTATUS_T)
7569 static bfd_boolean
7570 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7571 {
7572   lwpstatus_t lwpstat;
7573   char buf[100];
7574   char *name;
7575   size_t len;
7576   asection *sect;
7577
7578   if (note->descsz != sizeof (lwpstat)
7579 #if defined (HAVE_LWPXSTATUS_T)
7580       && note->descsz != sizeof (lwpxstatus_t)
7581 #endif
7582       )
7583     return TRUE;
7584
7585   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7586
7587   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7588   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7589
7590   /* Make a ".reg/999" section.  */
7591
7592   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7593   len = strlen (buf) + 1;
7594   name = bfd_alloc (abfd, len);
7595   if (name == NULL)
7596     return FALSE;
7597   memcpy (name, buf, len);
7598
7599   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7600   if (sect == NULL)
7601     return FALSE;
7602
7603 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7604   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7605   sect->filepos = note->descpos
7606     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7607 #endif
7608
7609 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7610   sect->size = sizeof (lwpstat.pr_reg);
7611   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7612 #endif
7613
7614   sect->alignment_power = 2;
7615
7616   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7617     return FALSE;
7618
7619   /* Make a ".reg2/999" section */
7620
7621   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7622   len = strlen (buf) + 1;
7623   name = bfd_alloc (abfd, len);
7624   if (name == NULL)
7625     return FALSE;
7626   memcpy (name, buf, len);
7627
7628   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7629   if (sect == NULL)
7630     return FALSE;
7631
7632 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7633   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7634   sect->filepos = note->descpos
7635     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7636 #endif
7637
7638 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7639   sect->size = sizeof (lwpstat.pr_fpreg);
7640   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7641 #endif
7642
7643   sect->alignment_power = 2;
7644
7645   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7646 }
7647 #endif /* defined (HAVE_LWPSTATUS_T) */
7648
7649 static bfd_boolean
7650 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7651 {
7652   char buf[30];
7653   char *name;
7654   size_t len;
7655   asection *sect;
7656   int type;
7657   int is_active_thread;
7658   bfd_vma base_addr;
7659
7660   if (note->descsz < 728)
7661     return TRUE;
7662
7663   if (! CONST_STRNEQ (note->namedata, "win32"))
7664     return TRUE;
7665
7666   type = bfd_get_32 (abfd, note->descdata);
7667
7668   switch (type)
7669     {
7670     case 1 /* NOTE_INFO_PROCESS */:
7671       /* FIXME: need to add ->core_command.  */
7672       /* process_info.pid */
7673       elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
7674       /* process_info.signal */
7675       elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
7676       break;
7677
7678     case 2 /* NOTE_INFO_THREAD */:
7679       /* Make a ".reg/999" section.  */
7680       /* thread_info.tid */
7681       sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
7682
7683       len = strlen (buf) + 1;
7684       name = bfd_alloc (abfd, len);
7685       if (name == NULL)
7686         return FALSE;
7687
7688       memcpy (name, buf, len);
7689
7690       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7691       if (sect == NULL)
7692         return FALSE;
7693
7694       /* sizeof (thread_info.thread_context) */
7695       sect->size = 716;
7696       /* offsetof (thread_info.thread_context) */
7697       sect->filepos = note->descpos + 12;
7698       sect->alignment_power = 2;
7699
7700       /* thread_info.is_active_thread */
7701       is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
7702
7703       if (is_active_thread)
7704         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7705           return FALSE;
7706       break;
7707
7708     case 3 /* NOTE_INFO_MODULE */:
7709       /* Make a ".module/xxxxxxxx" section.  */
7710       /* module_info.base_address */
7711       base_addr = bfd_get_32 (abfd, note->descdata + 4);
7712       sprintf (buf, ".module/%08lx", (long) base_addr);
7713
7714       len = strlen (buf) + 1;
7715       name = bfd_alloc (abfd, len);
7716       if (name == NULL)
7717         return FALSE;
7718
7719       memcpy (name, buf, len);
7720
7721       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7722
7723       if (sect == NULL)
7724         return FALSE;
7725
7726       sect->size = note->descsz;
7727       sect->filepos = note->descpos;
7728       sect->alignment_power = 2;
7729       break;
7730
7731     default:
7732       return TRUE;
7733     }
7734
7735   return TRUE;
7736 }
7737
7738 static bfd_boolean
7739 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7740 {
7741   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7742
7743   switch (note->type)
7744     {
7745     default:
7746       return TRUE;
7747
7748     case NT_PRSTATUS:
7749       if (bed->elf_backend_grok_prstatus)
7750         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7751           return TRUE;
7752 #if defined (HAVE_PRSTATUS_T)
7753       return elfcore_grok_prstatus (abfd, note);
7754 #else
7755       return TRUE;
7756 #endif
7757
7758 #if defined (HAVE_PSTATUS_T)
7759     case NT_PSTATUS:
7760       return elfcore_grok_pstatus (abfd, note);
7761 #endif
7762
7763 #if defined (HAVE_LWPSTATUS_T)
7764     case NT_LWPSTATUS:
7765       return elfcore_grok_lwpstatus (abfd, note);
7766 #endif
7767
7768     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
7769       return elfcore_grok_prfpreg (abfd, note);
7770
7771     case NT_WIN32PSTATUS:
7772       return elfcore_grok_win32pstatus (abfd, note);
7773
7774     case NT_PRXFPREG:           /* Linux SSE extension */
7775       if (note->namesz == 6
7776           && strcmp (note->namedata, "LINUX") == 0)
7777         return elfcore_grok_prxfpreg (abfd, note);
7778       else
7779         return TRUE;
7780
7781     case NT_PRPSINFO:
7782     case NT_PSINFO:
7783       if (bed->elf_backend_grok_psinfo)
7784         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7785           return TRUE;
7786 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7787       return elfcore_grok_psinfo (abfd, note);
7788 #else
7789       return TRUE;
7790 #endif
7791
7792     case NT_AUXV:
7793       {
7794         asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
7795                                                              SEC_HAS_CONTENTS);
7796
7797         if (sect == NULL)
7798           return FALSE;
7799         sect->size = note->descsz;
7800         sect->filepos = note->descpos;
7801         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7802
7803         return TRUE;
7804       }
7805     }
7806 }
7807
7808 static bfd_boolean
7809 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
7810 {
7811   elf_tdata (abfd)->build_id_size = note->descsz;
7812   elf_tdata (abfd)->build_id = bfd_alloc (abfd, note->descsz);
7813   if (elf_tdata (abfd)->build_id == NULL)
7814     return FALSE;
7815
7816   memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
7817
7818   return TRUE;
7819 }
7820
7821 static bfd_boolean
7822 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
7823 {
7824   switch (note->type)
7825     {
7826     default:
7827       return TRUE;
7828
7829     case NT_GNU_BUILD_ID:
7830       return elfobj_grok_gnu_build_id (abfd, note);
7831     }
7832 }
7833
7834 static bfd_boolean
7835 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7836 {
7837   char *cp;
7838
7839   cp = strchr (note->namedata, '@');
7840   if (cp != NULL)
7841     {
7842       *lwpidp = atoi(cp + 1);
7843       return TRUE;
7844     }
7845   return FALSE;
7846 }
7847
7848 static bfd_boolean
7849 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
7850 {
7851   /* Signal number at offset 0x08. */
7852   elf_tdata (abfd)->core_signal
7853     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7854
7855   /* Process ID at offset 0x50. */
7856   elf_tdata (abfd)->core_pid
7857     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7858
7859   /* Command name at 0x7c (max 32 bytes, including nul). */
7860   elf_tdata (abfd)->core_command
7861     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7862
7863   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7864                                           note);
7865 }
7866
7867 static bfd_boolean
7868 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
7869 {
7870   int lwp;
7871
7872   if (elfcore_netbsd_get_lwpid (note, &lwp))
7873     elf_tdata (abfd)->core_lwpid = lwp;
7874
7875   if (note->type == NT_NETBSDCORE_PROCINFO)
7876     {
7877       /* NetBSD-specific core "procinfo".  Note that we expect to
7878          find this note before any of the others, which is fine,
7879          since the kernel writes this note out first when it
7880          creates a core file.  */
7881
7882       return elfcore_grok_netbsd_procinfo (abfd, note);
7883     }
7884
7885   /* As of Jan 2002 there are no other machine-independent notes
7886      defined for NetBSD core files.  If the note type is less
7887      than the start of the machine-dependent note types, we don't
7888      understand it.  */
7889
7890   if (note->type < NT_NETBSDCORE_FIRSTMACH)
7891     return TRUE;
7892
7893
7894   switch (bfd_get_arch (abfd))
7895     {
7896       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7897          PT_GETFPREGS == mach+2.  */
7898
7899     case bfd_arch_alpha:
7900     case bfd_arch_sparc:
7901       switch (note->type)
7902         {
7903         case NT_NETBSDCORE_FIRSTMACH+0:
7904           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7905
7906         case NT_NETBSDCORE_FIRSTMACH+2:
7907           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7908
7909         default:
7910           return TRUE;
7911         }
7912
7913       /* On all other arch's, PT_GETREGS == mach+1 and
7914          PT_GETFPREGS == mach+3.  */
7915
7916     default:
7917       switch (note->type)
7918         {
7919         case NT_NETBSDCORE_FIRSTMACH+1:
7920           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7921
7922         case NT_NETBSDCORE_FIRSTMACH+3:
7923           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7924
7925         default:
7926           return TRUE;
7927         }
7928     }
7929     /* NOTREACHED */
7930 }
7931
7932 static bfd_boolean
7933 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
7934 {
7935   void *ddata = note->descdata;
7936   char buf[100];
7937   char *name;
7938   asection *sect;
7939   short sig;
7940   unsigned flags;
7941
7942   /* nto_procfs_status 'pid' field is at offset 0.  */
7943   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
7944
7945   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
7946   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
7947
7948   /* nto_procfs_status 'flags' field is at offset 8.  */
7949   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
7950
7951   /* nto_procfs_status 'what' field is at offset 14.  */
7952   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
7953     {
7954       elf_tdata (abfd)->core_signal = sig;
7955       elf_tdata (abfd)->core_lwpid = *tid;
7956     }
7957
7958   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
7959      do not come from signals so we make sure we set the current
7960      thread just in case.  */
7961   if (flags & 0x00000080)
7962     elf_tdata (abfd)->core_lwpid = *tid;
7963
7964   /* Make a ".qnx_core_status/%d" section.  */
7965   sprintf (buf, ".qnx_core_status/%ld", *tid);
7966
7967   name = bfd_alloc (abfd, strlen (buf) + 1);
7968   if (name == NULL)
7969     return FALSE;
7970   strcpy (name, buf);
7971
7972   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7973   if (sect == NULL)
7974     return FALSE;
7975
7976   sect->size            = note->descsz;
7977   sect->filepos         = note->descpos;
7978   sect->alignment_power = 2;
7979
7980   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
7981 }
7982
7983 static bfd_boolean
7984 elfcore_grok_nto_regs (bfd *abfd,
7985                        Elf_Internal_Note *note,
7986                        long tid,
7987                        char *base)
7988 {
7989   char buf[100];
7990   char *name;
7991   asection *sect;
7992
7993   /* Make a "(base)/%d" section.  */
7994   sprintf (buf, "%s/%ld", base, tid);
7995
7996   name = bfd_alloc (abfd, strlen (buf) + 1);
7997   if (name == NULL)
7998     return FALSE;
7999   strcpy (name, buf);
8000
8001   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8002   if (sect == NULL)
8003     return FALSE;
8004
8005   sect->size            = note->descsz;
8006   sect->filepos         = note->descpos;
8007   sect->alignment_power = 2;
8008
8009   /* This is the current thread.  */
8010   if (elf_tdata (abfd)->core_lwpid == tid)
8011     return elfcore_maybe_make_sect (abfd, base, sect);
8012
8013   return TRUE;
8014 }
8015
8016 #define BFD_QNT_CORE_INFO       7
8017 #define BFD_QNT_CORE_STATUS     8
8018 #define BFD_QNT_CORE_GREG       9
8019 #define BFD_QNT_CORE_FPREG      10
8020
8021 static bfd_boolean
8022 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8023 {
8024   /* Every GREG section has a STATUS section before it.  Store the
8025      tid from the previous call to pass down to the next gregs
8026      function.  */
8027   static long tid = 1;
8028
8029   switch (note->type)
8030     {
8031     case BFD_QNT_CORE_INFO:
8032       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8033     case BFD_QNT_CORE_STATUS:
8034       return elfcore_grok_nto_status (abfd, note, &tid);
8035     case BFD_QNT_CORE_GREG:
8036       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8037     case BFD_QNT_CORE_FPREG:
8038       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8039     default:
8040       return TRUE;
8041     }
8042 }
8043
8044 static bfd_boolean
8045 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8046 {
8047   char *name;
8048   asection *sect;
8049   size_t len;
8050
8051   /* Use note name as section name.  */
8052   len = note->namesz;
8053   name = bfd_alloc (abfd, len);
8054   if (name == NULL)
8055     return FALSE;
8056   memcpy (name, note->namedata, len);
8057   name[len - 1] = '\0';
8058
8059   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8060   if (sect == NULL)
8061     return FALSE;
8062
8063   sect->size            = note->descsz;
8064   sect->filepos         = note->descpos;
8065   sect->alignment_power = 1;
8066
8067   return TRUE;
8068 }
8069
8070 /* Function: elfcore_write_note
8071
8072    Inputs:
8073      buffer to hold note, and current size of buffer
8074      name of note
8075      type of note
8076      data for note
8077      size of data for note
8078
8079    Writes note to end of buffer.  ELF64 notes are written exactly as
8080    for ELF32, despite the current (as of 2006) ELF gabi specifying
8081    that they ought to have 8-byte namesz and descsz field, and have
8082    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
8083
8084    Return:
8085    Pointer to realloc'd buffer, *BUFSIZ updated.  */
8086
8087 char *
8088 elfcore_write_note (bfd *abfd,
8089                     char *buf,
8090                     int *bufsiz,
8091                     const char *name,
8092                     int type,
8093                     const void *input,
8094                     int size)
8095 {
8096   Elf_External_Note *xnp;
8097   size_t namesz;
8098   size_t newspace;
8099   char *dest;
8100
8101   namesz = 0;
8102   if (name != NULL)
8103     namesz = strlen (name) + 1;
8104
8105   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
8106
8107   buf = realloc (buf, *bufsiz + newspace);
8108   dest = buf + *bufsiz;
8109   *bufsiz += newspace;
8110   xnp = (Elf_External_Note *) dest;
8111   H_PUT_32 (abfd, namesz, xnp->namesz);
8112   H_PUT_32 (abfd, size, xnp->descsz);
8113   H_PUT_32 (abfd, type, xnp->type);
8114   dest = xnp->name;
8115   if (name != NULL)
8116     {
8117       memcpy (dest, name, namesz);
8118       dest += namesz;
8119       while (namesz & 3)
8120         {
8121           *dest++ = '\0';
8122           ++namesz;
8123         }
8124     }
8125   memcpy (dest, input, size);
8126   dest += size;
8127   while (size & 3)
8128     {
8129       *dest++ = '\0';
8130       ++size;
8131     }
8132   return buf;
8133 }
8134
8135 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8136 char *
8137 elfcore_write_prpsinfo (bfd  *abfd,
8138                         char *buf,
8139                         int  *bufsiz,
8140                         const char *fname,
8141                         const char *psargs)
8142 {
8143   const char *note_name = "CORE";
8144   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8145
8146   if (bed->elf_backend_write_core_note != NULL)
8147     {
8148       char *ret;
8149       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8150                                                  NT_PRPSINFO, fname, psargs);
8151       if (ret != NULL)
8152         return ret;
8153     }
8154
8155 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8156   if (bed->s->elfclass == ELFCLASS32)
8157     {
8158 #if defined (HAVE_PSINFO32_T)
8159       psinfo32_t data;
8160       int note_type = NT_PSINFO;
8161 #else
8162       prpsinfo32_t data;
8163       int note_type = NT_PRPSINFO;
8164 #endif
8165
8166       memset (&data, 0, sizeof (data));
8167       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8168       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8169       return elfcore_write_note (abfd, buf, bufsiz,
8170                                  note_name, note_type, &data, sizeof (data));
8171     }
8172   else
8173 #endif
8174     {
8175 #if defined (HAVE_PSINFO_T)
8176       psinfo_t data;
8177       int note_type = NT_PSINFO;
8178 #else
8179       prpsinfo_t data;
8180       int note_type = NT_PRPSINFO;
8181 #endif
8182
8183       memset (&data, 0, sizeof (data));
8184       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8185       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8186       return elfcore_write_note (abfd, buf, bufsiz,
8187                                  note_name, note_type, &data, sizeof (data));
8188     }
8189 }
8190 #endif  /* PSINFO_T or PRPSINFO_T */
8191
8192 #if defined (HAVE_PRSTATUS_T)
8193 char *
8194 elfcore_write_prstatus (bfd *abfd,
8195                         char *buf,
8196                         int *bufsiz,
8197                         long pid,
8198                         int cursig,
8199                         const void *gregs)
8200 {
8201   const char *note_name = "CORE";
8202   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8203
8204   if (bed->elf_backend_write_core_note != NULL)
8205     {
8206       char *ret;
8207       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8208                                                  NT_PRSTATUS,
8209                                                  pid, cursig, gregs);
8210       if (ret != NULL)
8211         return ret;
8212     }
8213
8214 #if defined (HAVE_PRSTATUS32_T)
8215   if (bed->s->elfclass == ELFCLASS32)
8216     {
8217       prstatus32_t prstat;
8218
8219       memset (&prstat, 0, sizeof (prstat));
8220       prstat.pr_pid = pid;
8221       prstat.pr_cursig = cursig;
8222       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8223       return elfcore_write_note (abfd, buf, bufsiz, note_name,
8224                                  NT_PRSTATUS, &prstat, sizeof (prstat));
8225     }
8226   else
8227 #endif
8228     {
8229       prstatus_t prstat;
8230
8231       memset (&prstat, 0, sizeof (prstat));
8232       prstat.pr_pid = pid;
8233       prstat.pr_cursig = cursig;
8234       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8235       return elfcore_write_note (abfd, buf, bufsiz, note_name,
8236                                  NT_PRSTATUS, &prstat, sizeof (prstat));
8237     }
8238 }
8239 #endif /* HAVE_PRSTATUS_T */
8240
8241 #if defined (HAVE_LWPSTATUS_T)
8242 char *
8243 elfcore_write_lwpstatus (bfd *abfd,
8244                          char *buf,
8245                          int *bufsiz,
8246                          long pid,
8247                          int cursig,
8248                          const void *gregs)
8249 {
8250   lwpstatus_t lwpstat;
8251   const char *note_name = "CORE";
8252
8253   memset (&lwpstat, 0, sizeof (lwpstat));
8254   lwpstat.pr_lwpid  = pid >> 16;
8255   lwpstat.pr_cursig = cursig;
8256 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8257   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8258 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8259 #if !defined(gregs)
8260   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8261           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8262 #else
8263   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8264           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8265 #endif
8266 #endif
8267   return elfcore_write_note (abfd, buf, bufsiz, note_name,
8268                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8269 }
8270 #endif /* HAVE_LWPSTATUS_T */
8271
8272 #if defined (HAVE_PSTATUS_T)
8273 char *
8274 elfcore_write_pstatus (bfd *abfd,
8275                        char *buf,
8276                        int *bufsiz,
8277                        long pid,
8278                        int cursig ATTRIBUTE_UNUSED,
8279                        const void *gregs ATTRIBUTE_UNUSED)
8280 {
8281   const char *note_name = "CORE";
8282 #if defined (HAVE_PSTATUS32_T)
8283   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8284
8285   if (bed->s->elfclass == ELFCLASS32)
8286     {
8287       pstatus32_t pstat;
8288
8289       memset (&pstat, 0, sizeof (pstat));
8290       pstat.pr_pid = pid & 0xffff;
8291       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8292                                 NT_PSTATUS, &pstat, sizeof (pstat));
8293       return buf;
8294     }
8295   else
8296 #endif
8297     {
8298       pstatus_t pstat;
8299
8300       memset (&pstat, 0, sizeof (pstat));
8301       pstat.pr_pid = pid & 0xffff;
8302       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8303                                 NT_PSTATUS, &pstat, sizeof (pstat));
8304       return buf;
8305     }
8306 }
8307 #endif /* HAVE_PSTATUS_T */
8308
8309 char *
8310 elfcore_write_prfpreg (bfd *abfd,
8311                        char *buf,
8312                        int *bufsiz,
8313                        const void *fpregs,
8314                        int size)
8315 {
8316   const char *note_name = "CORE";
8317   return elfcore_write_note (abfd, buf, bufsiz,
8318                              note_name, NT_FPREGSET, fpregs, size);
8319 }
8320
8321 char *
8322 elfcore_write_prxfpreg (bfd *abfd,
8323                         char *buf,
8324                         int *bufsiz,
8325                         const void *xfpregs,
8326                         int size)
8327 {
8328   char *note_name = "LINUX";
8329   return elfcore_write_note (abfd, buf, bufsiz,
8330                              note_name, NT_PRXFPREG, xfpregs, size);
8331 }
8332
8333 static bfd_boolean
8334 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
8335 {
8336   char *p;
8337
8338   p = buf;
8339   while (p < buf + size)
8340     {
8341       /* FIXME: bad alignment assumption.  */
8342       Elf_External_Note *xnp = (Elf_External_Note *) p;
8343       Elf_Internal_Note in;
8344
8345       in.type = H_GET_32 (abfd, xnp->type);
8346
8347       in.namesz = H_GET_32 (abfd, xnp->namesz);
8348       in.namedata = xnp->name;
8349
8350       in.descsz = H_GET_32 (abfd, xnp->descsz);
8351       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8352       in.descpos = offset + (in.descdata - buf);
8353
8354       switch (bfd_get_format (abfd))
8355         {
8356         default:
8357           return TRUE;
8358
8359         case bfd_core:
8360           if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
8361             {
8362               if (! elfcore_grok_netbsd_note (abfd, &in))
8363                 return FALSE;
8364             }
8365           else if (CONST_STRNEQ (in.namedata, "QNX"))
8366             {
8367               if (! elfcore_grok_nto_note (abfd, &in))
8368                 return FALSE;
8369             }
8370           else if (CONST_STRNEQ (in.namedata, "SPU/"))
8371             {
8372               if (! elfcore_grok_spu_note (abfd, &in))
8373                 return FALSE;
8374             }
8375           else
8376             {
8377               if (! elfcore_grok_note (abfd, &in))
8378                 return FALSE;
8379             }
8380           break;
8381
8382         case bfd_object:
8383           if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
8384             {
8385               if (! elfobj_grok_gnu_note (abfd, &in))
8386                 return FALSE;
8387             }
8388           break;
8389         }
8390
8391       p = in.descdata + BFD_ALIGN (in.descsz, 4);
8392     }
8393
8394   return TRUE;
8395 }
8396
8397 static bfd_boolean
8398 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
8399 {
8400   char *buf;
8401
8402   if (size <= 0)
8403     return TRUE;
8404
8405   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
8406     return FALSE;
8407
8408   buf = bfd_malloc (size);
8409   if (buf == NULL)
8410     return FALSE;
8411
8412   if (bfd_bread (buf, size, abfd) != size
8413       || !elf_parse_notes (abfd, buf, size, offset))
8414     {
8415       free (buf);
8416       return FALSE;
8417     }
8418
8419   free (buf);
8420   return TRUE;
8421 }
8422 \f
8423 /* Providing external access to the ELF program header table.  */
8424
8425 /* Return an upper bound on the number of bytes required to store a
8426    copy of ABFD's program header table entries.  Return -1 if an error
8427    occurs; bfd_get_error will return an appropriate code.  */
8428
8429 long
8430 bfd_get_elf_phdr_upper_bound (bfd *abfd)
8431 {
8432   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8433     {
8434       bfd_set_error (bfd_error_wrong_format);
8435       return -1;
8436     }
8437
8438   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
8439 }
8440
8441 /* Copy ABFD's program header table entries to *PHDRS.  The entries
8442    will be stored as an array of Elf_Internal_Phdr structures, as
8443    defined in include/elf/internal.h.  To find out how large the
8444    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8445
8446    Return the number of program header table entries read, or -1 if an
8447    error occurs; bfd_get_error will return an appropriate code.  */
8448
8449 int
8450 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
8451 {
8452   int num_phdrs;
8453
8454   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8455     {
8456       bfd_set_error (bfd_error_wrong_format);
8457       return -1;
8458     }
8459
8460   num_phdrs = elf_elfheader (abfd)->e_phnum;
8461   memcpy (phdrs, elf_tdata (abfd)->phdr,
8462           num_phdrs * sizeof (Elf_Internal_Phdr));
8463
8464   return num_phdrs;
8465 }
8466
8467 enum elf_reloc_type_class
8468 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8469 {
8470   return reloc_class_normal;
8471 }
8472
8473 /* For RELA architectures, return the relocation value for a
8474    relocation against a local symbol.  */
8475
8476 bfd_vma
8477 _bfd_elf_rela_local_sym (bfd *abfd,
8478                          Elf_Internal_Sym *sym,
8479                          asection **psec,
8480                          Elf_Internal_Rela *rel)
8481 {
8482   asection *sec = *psec;
8483   bfd_vma relocation;
8484
8485   relocation = (sec->output_section->vma
8486                 + sec->output_offset
8487                 + sym->st_value);
8488   if ((sec->flags & SEC_MERGE)
8489       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8490       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8491     {
8492       rel->r_addend =
8493         _bfd_merged_section_offset (abfd, psec,
8494                                     elf_section_data (sec)->sec_info,
8495                                     sym->st_value + rel->r_addend);
8496       if (sec != *psec)
8497         {
8498           /* If we have changed the section, and our original section is
8499              marked with SEC_EXCLUDE, it means that the original
8500              SEC_MERGE section has been completely subsumed in some
8501              other SEC_MERGE section.  In this case, we need to leave
8502              some info around for --emit-relocs.  */
8503           if ((sec->flags & SEC_EXCLUDE) != 0)
8504             sec->kept_section = *psec;
8505           sec = *psec;
8506         }
8507       rel->r_addend -= relocation;
8508       rel->r_addend += sec->output_section->vma + sec->output_offset;
8509     }
8510   return relocation;
8511 }
8512
8513 bfd_vma
8514 _bfd_elf_rel_local_sym (bfd *abfd,
8515                         Elf_Internal_Sym *sym,
8516                         asection **psec,
8517                         bfd_vma addend)
8518 {
8519   asection *sec = *psec;
8520
8521   if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8522     return sym->st_value + addend;
8523
8524   return _bfd_merged_section_offset (abfd, psec,
8525                                      elf_section_data (sec)->sec_info,
8526                                      sym->st_value + addend);
8527 }
8528
8529 bfd_vma
8530 _bfd_elf_section_offset (bfd *abfd,
8531                          struct bfd_link_info *info,
8532                          asection *sec,
8533                          bfd_vma offset)
8534 {
8535   switch (sec->sec_info_type)
8536     {
8537     case ELF_INFO_TYPE_STABS:
8538       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8539                                        offset);
8540     case ELF_INFO_TYPE_EH_FRAME:
8541       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8542     default:
8543       return offset;
8544     }
8545 }
8546 \f
8547 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
8548    reconstruct an ELF file by reading the segments out of remote memory
8549    based on the ELF file header at EHDR_VMA and the ELF program headers it
8550    points to.  If not null, *LOADBASEP is filled in with the difference
8551    between the VMAs from which the segments were read, and the VMAs the
8552    file headers (and hence BFD's idea of each section's VMA) put them at.
8553
8554    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8555    remote memory at target address VMA into the local buffer at MYADDR; it
8556    should return zero on success or an `errno' code on failure.  TEMPL must
8557    be a BFD for an ELF target with the word size and byte order found in
8558    the remote memory.  */
8559
8560 bfd *
8561 bfd_elf_bfd_from_remote_memory
8562   (bfd *templ,
8563    bfd_vma ehdr_vma,
8564    bfd_vma *loadbasep,
8565    int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8566 {
8567   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8568     (templ, ehdr_vma, loadbasep, target_read_memory);
8569 }
8570 \f
8571 long
8572 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8573                                long symcount ATTRIBUTE_UNUSED,
8574                                asymbol **syms ATTRIBUTE_UNUSED,
8575                                long dynsymcount,
8576                                asymbol **dynsyms,
8577                                asymbol **ret)
8578 {
8579   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8580   asection *relplt;
8581   asymbol *s;
8582   const char *relplt_name;
8583   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8584   arelent *p;
8585   long count, i, n;
8586   size_t size;
8587   Elf_Internal_Shdr *hdr;
8588   char *names;
8589   asection *plt;
8590
8591   *ret = NULL;
8592
8593   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8594     return 0;
8595
8596   if (dynsymcount <= 0)
8597     return 0;
8598
8599   if (!bed->plt_sym_val)
8600     return 0;
8601
8602   relplt_name = bed->relplt_name;
8603   if (relplt_name == NULL)
8604     relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8605   relplt = bfd_get_section_by_name (abfd, relplt_name);
8606   if (relplt == NULL)
8607     return 0;
8608
8609   hdr = &elf_section_data (relplt)->this_hdr;
8610   if (hdr->sh_link != elf_dynsymtab (abfd)
8611       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8612     return 0;
8613
8614   plt = bfd_get_section_by_name (abfd, ".plt");
8615   if (plt == NULL)
8616     return 0;
8617
8618   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8619   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8620     return -1;
8621
8622   count = relplt->size / hdr->sh_entsize;
8623   size = count * sizeof (asymbol);
8624   p = relplt->relocation;
8625   for (i = 0; i < count; i++, p++)
8626     size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8627
8628   s = *ret = bfd_malloc (size);
8629   if (s == NULL)
8630     return -1;
8631
8632   names = (char *) (s + count);
8633   p = relplt->relocation;
8634   n = 0;
8635   for (i = 0; i < count; i++, s++, p++)
8636     {
8637       size_t len;
8638       bfd_vma addr;
8639
8640       addr = bed->plt_sym_val (i, plt, p);
8641       if (addr == (bfd_vma) -1)
8642         continue;
8643
8644       *s = **p->sym_ptr_ptr;
8645       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
8646          we are defining a symbol, ensure one of them is set.  */
8647       if ((s->flags & BSF_LOCAL) == 0)
8648         s->flags |= BSF_GLOBAL;
8649       s->section = plt;
8650       s->value = addr - plt->vma;
8651       s->name = names;
8652       len = strlen ((*p->sym_ptr_ptr)->name);
8653       memcpy (names, (*p->sym_ptr_ptr)->name, len);
8654       names += len;
8655       memcpy (names, "@plt", sizeof ("@plt"));
8656       names += sizeof ("@plt");
8657       ++n;
8658     }
8659
8660   return n;
8661 }
8662
8663 /* It is only used by x86-64 so far.  */
8664 asection _bfd_elf_large_com_section
8665   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
8666                       SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
8667
8668 void
8669 _bfd_elf_set_osabi (bfd * abfd,
8670                     struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
8671 {
8672   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
8673
8674   i_ehdrp = elf_elfheader (abfd);
8675
8676   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
8677 }
8678
8679
8680 /* Return TRUE for ELF symbol types that represent functions.
8681    This is the default version of this function, which is sufficient for
8682    most targets.  It returns true if TYPE is STT_FUNC.  */
8683
8684 bfd_boolean
8685 _bfd_elf_is_function_type (unsigned int type)
8686 {
8687   return (type == STT_FUNC);
8688 }