bfd/elf.c

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