bfd/elf.c

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