bfd/elf.c

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