bfd/elf.c

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