bfd/elf.c

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