bfd/elf.c

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