bfd/elf.c

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