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       break;
2117
2118     case SHT_GNU_verneed:
2119       elf_dynverref (abfd) = shindex;
2120       elf_tdata (abfd)->dynverref_hdr = *hdr;
2121       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2122       break;
2123
2124     case SHT_SHLIB:
2125       return TRUE;
2126
2127     case SHT_GROUP:
2128       /* We need a BFD section for objcopy and relocatable linking,
2129          and it's handy to have the signature available as the section
2130          name.  */
2131       if (hdr->sh_entsize != GRP_ENTRY_SIZE)
2132         return FALSE;
2133       name = group_signature (abfd, hdr);
2134       if (name == NULL)
2135         return FALSE;
2136       if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2137         return FALSE;
2138       if (hdr->contents != NULL)
2139         {
2140           Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
2141           unsigned int n_elt = hdr->sh_size / 4;
2142           asection *s;
2143
2144           if (idx->flags & GRP_COMDAT)
2145             hdr->bfd_section->flags
2146               |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2147
2148           /* We try to keep the same section order as it comes in.  */
2149           idx += n_elt;
2150           while (--n_elt != 0)
2151             if ((s = (--idx)->shdr->bfd_section) != NULL
2152                 && elf_next_in_group (s) != NULL)
2153               {
2154                 elf_next_in_group (hdr->bfd_section) = s;
2155                 break;
2156               }
2157         }
2158       break;
2159
2160     default:
2161       /* Check for any processor-specific section types.  */
2162       if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
2163         return TRUE;
2164
2165       if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
2166         {
2167           if ((hdr->sh_flags & SHF_ALLOC) != 0)
2168             /* FIXME: How to properly handle allocated section reserved
2169                for applications?  */
2170             (*_bfd_error_handler)
2171               (_("%B: don't know how to handle allocated, application "
2172                  "specific section `%s' [0x%8x]"),
2173                abfd, name, hdr->sh_type);
2174           else
2175             /* Allow sections reserved for applications.  */
2176             return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2177                                                     shindex);
2178         }
2179       else if (hdr->sh_type >= SHT_LOPROC
2180                && hdr->sh_type <= SHT_HIPROC)
2181         /* FIXME: We should handle this section.  */
2182         (*_bfd_error_handler)
2183           (_("%B: don't know how to handle processor specific section "
2184              "`%s' [0x%8x]"),
2185            abfd, name, hdr->sh_type);
2186       else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
2187         /* FIXME: We should handle this section.  */
2188         (*_bfd_error_handler)
2189           (_("%B: don't know how to handle OS specific section "
2190              "`%s' [0x%8x]"),
2191            abfd, name, hdr->sh_type);
2192       else
2193         /* FIXME: We should handle this section.  */
2194         (*_bfd_error_handler)
2195           (_("%B: don't know how to handle section `%s' [0x%8x]"),
2196            abfd, name, hdr->sh_type);
2197
2198       return FALSE;
2199     }
2200
2201   return TRUE;
2202 }
2203
2204 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2205    Return SEC for sections that have no elf section, and NULL on error.  */
2206
2207 asection *
2208 bfd_section_from_r_symndx (bfd *abfd,
2209                            struct sym_sec_cache *cache,
2210                            asection *sec,
2211                            unsigned long r_symndx)
2212 {
2213   Elf_Internal_Shdr *symtab_hdr;
2214   unsigned char esym[sizeof (Elf64_External_Sym)];
2215   Elf_External_Sym_Shndx eshndx;
2216   Elf_Internal_Sym isym;
2217   unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2218
2219   if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
2220     return cache->sec[ent];
2221
2222   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2223   if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2224                             &isym, esym, &eshndx) == NULL)
2225     return NULL;
2226
2227   if (cache->abfd != abfd)
2228     {
2229       memset (cache->indx, -1, sizeof (cache->indx));
2230       cache->abfd = abfd;
2231     }
2232   cache->indx[ent] = r_symndx;
2233   cache->sec[ent] = sec;
2234   if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
2235       || isym.st_shndx > SHN_HIRESERVE)
2236     {
2237       asection *s;
2238       s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2239       if (s != NULL)
2240         cache->sec[ent] = s;
2241     }
2242   return cache->sec[ent];
2243 }
2244
2245 /* Given an ELF section number, retrieve the corresponding BFD
2246    section.  */
2247
2248 asection *
2249 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
2250 {
2251   if (index >= elf_numsections (abfd))
2252     return NULL;
2253   return elf_elfsections (abfd)[index]->bfd_section;
2254 }
2255
2256 static const struct bfd_elf_special_section special_sections_b[] =
2257 {
2258   { ".bss",            4, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2259   { NULL,              0,  0, 0,            0 }
2260 };
2261
2262 static const struct bfd_elf_special_section special_sections_c[] =
2263 {
2264   { ".comment",        8,  0, SHT_PROGBITS, 0 },
2265   { NULL,              0,  0, 0,            0 }
2266 };
2267
2268 static const struct bfd_elf_special_section special_sections_d[] =
2269 {
2270   { ".data",           5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2271   { ".data1",          6,  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2272   { ".debug",          6,  0, SHT_PROGBITS, 0 },
2273   { ".debug_line",    11,  0, SHT_PROGBITS, 0 },
2274   { ".debug_info",    11,  0, SHT_PROGBITS, 0 },
2275   { ".debug_abbrev",  13,  0, SHT_PROGBITS, 0 },
2276   { ".debug_aranges", 14,  0, SHT_PROGBITS, 0 },
2277   { ".dynamic",        8,  0, SHT_DYNAMIC,  SHF_ALLOC },
2278   { ".dynstr",         7,  0, SHT_STRTAB,   SHF_ALLOC },
2279   { ".dynsym",         7,  0, SHT_DYNSYM,   SHF_ALLOC },
2280   { NULL,              0,  0, 0,            0 }
2281 };
2282
2283 static const struct bfd_elf_special_section special_sections_f[] =
2284 {
2285   { ".fini",           5,  0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2286   { ".fini_array",    11,  0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2287   { NULL,              0,  0, 0,            0 }
2288 };
2289
2290 static const struct bfd_elf_special_section special_sections_g[] =
2291 {
2292   { ".gnu.linkonce.b",15, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2293   { ".got",            4,  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2294   { ".gnu.version",   12,  0, SHT_GNU_versym, 0 },
2295   { ".gnu.version_d", 14,  0, SHT_GNU_verdef, 0 },
2296   { ".gnu.version_r", 14,  0, SHT_GNU_verneed, 0 },
2297   { ".gnu.liblist",   12,  0, SHT_GNU_LIBLIST, SHF_ALLOC },
2298   { ".gnu.conflict",  13,  0, SHT_RELA,     SHF_ALLOC },
2299   { NULL,              0,  0, 0,            0 }
2300 };
2301
2302 static const struct bfd_elf_special_section special_sections_h[] =
2303 {
2304   { ".hash",           5,  0, SHT_HASH,     SHF_ALLOC },
2305   { NULL,              0,  0, 0,            0 }
2306 };
2307
2308 static const struct bfd_elf_special_section special_sections_i[] =
2309 {
2310   { ".init",           5,  0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2311   { ".init_array",    11,  0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2312   { ".interp",         7,  0, SHT_PROGBITS, 0 },
2313   { NULL,              0,  0, 0,            0 }
2314 };
2315
2316 static const struct bfd_elf_special_section special_sections_l[] =
2317 {
2318   { ".line",           5,  0, SHT_PROGBITS, 0 },
2319   { NULL,              0,  0, 0,            0 }
2320 };
2321
2322 static const struct bfd_elf_special_section special_sections_n[] =
2323 {
2324   { ".note.GNU-stack",15,  0, SHT_PROGBITS, 0 },
2325   { ".note",           5, -1, SHT_NOTE,     0 },
2326   { NULL,              0,  0, 0,            0 }
2327 };
2328
2329 static const struct bfd_elf_special_section special_sections_p[] =
2330 {
2331   { ".preinit_array", 14,  0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2332   { ".plt",            4,  0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2333   { NULL,              0,  0, 0,            0 }
2334 };
2335
2336 static const struct bfd_elf_special_section special_sections_r[] =
2337 {
2338   { ".rodata",         7, -2, SHT_PROGBITS, SHF_ALLOC },
2339   { ".rodata1",        8,  0, SHT_PROGBITS, SHF_ALLOC },
2340   { ".rela",           5, -1, SHT_RELA,     0 },
2341   { ".rel",            4, -1, SHT_REL,      0 },
2342   { NULL,              0,  0, 0,            0 }
2343 };
2344
2345 static const struct bfd_elf_special_section special_sections_s[] =
2346 {
2347   { ".shstrtab",       9,  0, SHT_STRTAB,   0 },
2348   { ".strtab",         7,  0, SHT_STRTAB,   0 },
2349   { ".symtab",         7,  0, SHT_SYMTAB,   0 },
2350   { ".stabstr",        5,  3, SHT_STRTAB,   0 },
2351   { NULL,              0,  0, 0,            0 }
2352 };
2353
2354 static const struct bfd_elf_special_section special_sections_t[] =
2355 {
2356   { ".text",           5, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2357   { ".tbss",           5, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_TLS },
2358   { ".tdata",          6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2359   { NULL,              0,  0, 0,            0 }
2360 };
2361
2362 static const struct bfd_elf_special_section *special_sections[] =
2363 {
2364   special_sections_b,           /* 'b' */
2365   special_sections_c,           /* 'b' */
2366   special_sections_d,           /* 'd' */
2367   NULL,                         /* 'e' */
2368   special_sections_f,           /* 'f' */
2369   special_sections_g,           /* 'g' */
2370   special_sections_h,           /* 'h' */
2371   special_sections_i,           /* 'i' */
2372   NULL,                         /* 'j' */
2373   NULL,                         /* 'k' */
2374   special_sections_l,           /* 'l' */
2375   NULL,                         /* 'm' */
2376   special_sections_n,           /* 'n' */
2377   NULL,                         /* 'o' */
2378   special_sections_p,           /* 'p' */
2379   NULL,                         /* 'q' */
2380   special_sections_r,           /* 'r' */
2381   special_sections_s,           /* 's' */
2382   special_sections_t,           /* 't' */
2383 };
2384
2385 const struct bfd_elf_special_section *
2386 _bfd_elf_get_special_section (const char *name,
2387                               const struct bfd_elf_special_section *spec,
2388                               unsigned int rela)
2389 {
2390   int i;
2391   int len;
2392
2393   len = strlen (name);
2394
2395   for (i = 0; spec[i].prefix != NULL; i++)
2396     {
2397       int suffix_len;
2398       int prefix_len = spec[i].prefix_length;
2399
2400       if (len < prefix_len)
2401         continue;
2402       if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2403         continue;
2404
2405       suffix_len = spec[i].suffix_length;
2406       if (suffix_len <= 0)
2407         {
2408           if (name[prefix_len] != 0)
2409             {
2410               if (suffix_len == 0)
2411                 continue;
2412               if (name[prefix_len] != '.'
2413                   && (suffix_len == -2
2414                       || (rela && spec[i].type == SHT_REL)))
2415                 continue;
2416             }
2417         }
2418       else
2419         {
2420           if (len < prefix_len + suffix_len)
2421             continue;
2422           if (memcmp (name + len - suffix_len,
2423                       spec[i].prefix + prefix_len,
2424                       suffix_len) != 0)
2425             continue;
2426         }
2427       return &spec[i];
2428     }
2429
2430   return NULL;
2431 }
2432
2433 const struct bfd_elf_special_section *
2434 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2435 {
2436   int i;
2437   const struct bfd_elf_special_section *spec;
2438   const struct elf_backend_data *bed;
2439
2440   /* See if this is one of the special sections.  */
2441   if (sec->name == NULL)
2442     return NULL;
2443
2444   bed = get_elf_backend_data (abfd);
2445   spec = bed->special_sections;
2446   if (spec)
2447     {
2448       spec = _bfd_elf_get_special_section (sec->name,
2449                                            bed->special_sections,
2450                                            sec->use_rela_p);
2451       if (spec != NULL)
2452         return spec;
2453     }
2454
2455   if (sec->name[0] != '.')
2456     return NULL;
2457
2458   i = sec->name[1] - 'b';
2459   if (i < 0 || i > 't' - 'b')
2460     return NULL;
2461
2462   spec = special_sections[i];
2463
2464   if (spec == NULL)
2465     return NULL;
2466
2467   return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2468 }
2469
2470 bfd_boolean
2471 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2472 {
2473   struct bfd_elf_section_data *sdata;
2474   const struct elf_backend_data *bed;
2475   const struct bfd_elf_special_section *ssect;
2476
2477   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2478   if (sdata == NULL)
2479     {
2480       sdata = bfd_zalloc (abfd, sizeof (*sdata));
2481       if (sdata == NULL)
2482         return FALSE;
2483       sec->used_by_bfd = sdata;
2484     }
2485
2486   /* Indicate whether or not this section should use RELA relocations.  */
2487   bed = get_elf_backend_data (abfd);
2488   sec->use_rela_p = bed->default_use_rela_p;
2489
2490   /* When we read a file, we don't need section type and flags unless
2491      it is a linker created section.  They will be overridden in
2492      _bfd_elf_make_section_from_shdr anyway.  */
2493   if (abfd->direction != read_direction
2494       || (sec->flags & SEC_LINKER_CREATED) != 0)
2495     {
2496       ssect = (*bed->get_sec_type_attr) (abfd, sec);
2497       if (ssect != NULL)
2498         {
2499           elf_section_type (sec) = ssect->type;
2500           elf_section_flags (sec) = ssect->attr;
2501         }
2502     }
2503
2504   return TRUE;
2505 }
2506
2507 /* Create a new bfd section from an ELF program header.
2508
2509    Since program segments have no names, we generate a synthetic name
2510    of the form segment<NUM>, where NUM is generally the index in the
2511    program header table.  For segments that are split (see below) we
2512    generate the names segment<NUM>a and segment<NUM>b.
2513
2514    Note that some program segments may have a file size that is different than
2515    (less than) the memory size.  All this means is that at execution the
2516    system must allocate the amount of memory specified by the memory size,
2517    but only initialize it with the first "file size" bytes read from the
2518    file.  This would occur for example, with program segments consisting
2519    of combined data+bss.
2520
2521    To handle the above situation, this routine generates TWO bfd sections
2522    for the single program segment.  The first has the length specified by
2523    the file size of the segment, and the second has the length specified
2524    by the difference between the two sizes.  In effect, the segment is split
2525    into it's initialized and uninitialized parts.
2526
2527  */
2528
2529 bfd_boolean
2530 _bfd_elf_make_section_from_phdr (bfd *abfd,
2531                                  Elf_Internal_Phdr *hdr,
2532                                  int index,
2533                                  const char *typename)
2534 {
2535   asection *newsect;
2536   char *name;
2537   char namebuf[64];
2538   size_t len;
2539   int split;
2540
2541   split = ((hdr->p_memsz > 0)
2542             && (hdr->p_filesz > 0)
2543             && (hdr->p_memsz > hdr->p_filesz));
2544   sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2545   len = strlen (namebuf) + 1;
2546   name = bfd_alloc (abfd, len);
2547   if (!name)
2548     return FALSE;
2549   memcpy (name, namebuf, len);
2550   newsect = bfd_make_section (abfd, name);
2551   if (newsect == NULL)
2552     return FALSE;
2553   newsect->vma = hdr->p_vaddr;
2554   newsect->lma = hdr->p_paddr;
2555   newsect->size = hdr->p_filesz;
2556   newsect->filepos = hdr->p_offset;
2557   newsect->flags |= SEC_HAS_CONTENTS;
2558   newsect->alignment_power = bfd_log2 (hdr->p_align);
2559   if (hdr->p_type == PT_LOAD)
2560     {
2561       newsect->flags |= SEC_ALLOC;
2562       newsect->flags |= SEC_LOAD;
2563       if (hdr->p_flags & PF_X)
2564         {
2565           /* FIXME: all we known is that it has execute PERMISSION,
2566              may be data.  */
2567           newsect->flags |= SEC_CODE;
2568         }
2569     }
2570   if (!(hdr->p_flags & PF_W))
2571     {
2572       newsect->flags |= SEC_READONLY;
2573     }
2574
2575   if (split)
2576     {
2577       sprintf (namebuf, "%s%db", typename, index);
2578       len = strlen (namebuf) + 1;
2579       name = bfd_alloc (abfd, len);
2580       if (!name)
2581         return FALSE;
2582       memcpy (name, namebuf, len);
2583       newsect = bfd_make_section (abfd, name);
2584       if (newsect == NULL)
2585         return FALSE;
2586       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2587       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2588       newsect->size = hdr->p_memsz - hdr->p_filesz;
2589       if (hdr->p_type == PT_LOAD)
2590         {
2591           newsect->flags |= SEC_ALLOC;
2592           if (hdr->p_flags & PF_X)
2593             newsect->flags |= SEC_CODE;
2594         }
2595       if (!(hdr->p_flags & PF_W))
2596         newsect->flags |= SEC_READONLY;
2597     }
2598
2599   return TRUE;
2600 }
2601
2602 bfd_boolean
2603 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2604 {
2605   const struct elf_backend_data *bed;
2606
2607   switch (hdr->p_type)
2608     {
2609     case PT_NULL:
2610       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2611
2612     case PT_LOAD:
2613       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2614
2615     case PT_DYNAMIC:
2616       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2617
2618     case PT_INTERP:
2619       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2620
2621     case PT_NOTE:
2622       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2623         return FALSE;
2624       if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2625         return FALSE;
2626       return TRUE;
2627
2628     case PT_SHLIB:
2629       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2630
2631     case PT_PHDR:
2632       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2633
2634     case PT_GNU_EH_FRAME:
2635       return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2636                                               "eh_frame_hdr");
2637
2638     case PT_GNU_STACK:
2639       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2640
2641     case PT_GNU_RELRO:
2642       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2643
2644     default:
2645       /* Check for any processor-specific program segment types.  */
2646       bed = get_elf_backend_data (abfd);
2647       return bed->elf_backend_section_from_phdr (abfd, hdr, index, "proc");
2648     }
2649 }
2650
2651 /* Initialize REL_HDR, the section-header for new section, containing
2652    relocations against ASECT.  If USE_RELA_P is TRUE, we use RELA
2653    relocations; otherwise, we use REL relocations.  */
2654
2655 bfd_boolean
2656 _bfd_elf_init_reloc_shdr (bfd *abfd,
2657                           Elf_Internal_Shdr *rel_hdr,
2658                           asection *asect,
2659                           bfd_boolean use_rela_p)
2660 {
2661   char *name;
2662   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2663   bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2664
2665   name = bfd_alloc (abfd, amt);
2666   if (name == NULL)
2667     return FALSE;
2668   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2669   rel_hdr->sh_name =
2670     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2671                                         FALSE);
2672   if (rel_hdr->sh_name == (unsigned int) -1)
2673     return FALSE;
2674   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2675   rel_hdr->sh_entsize = (use_rela_p
2676                          ? bed->s->sizeof_rela
2677                          : bed->s->sizeof_rel);
2678   rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2679   rel_hdr->sh_flags = 0;
2680   rel_hdr->sh_addr = 0;
2681   rel_hdr->sh_size = 0;
2682   rel_hdr->sh_offset = 0;
2683
2684   return TRUE;
2685 }
2686
2687 /* Set up an ELF internal section header for a section.  */
2688
2689 static void
2690 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2691 {
2692   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2693   bfd_boolean *failedptr = failedptrarg;
2694   Elf_Internal_Shdr *this_hdr;
2695
2696   if (*failedptr)
2697     {
2698       /* We already failed; just get out of the bfd_map_over_sections
2699          loop.  */
2700       return;
2701     }
2702
2703   this_hdr = &elf_section_data (asect)->this_hdr;
2704
2705   this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2706                                                           asect->name, FALSE);
2707   if (this_hdr->sh_name == (unsigned int) -1)
2708     {
2709       *failedptr = TRUE;
2710       return;
2711     }
2712
2713   /* Don't clear sh_flags. Assembler may set additional bits.  */
2714
2715   if ((asect->flags & SEC_ALLOC) != 0
2716       || asect->user_set_vma)
2717     this_hdr->sh_addr = asect->vma;
2718   else
2719     this_hdr->sh_addr = 0;
2720
2721   this_hdr->sh_offset = 0;
2722   this_hdr->sh_size = asect->size;
2723   this_hdr->sh_link = 0;
2724   this_hdr->sh_addralign = 1 << asect->alignment_power;
2725   /* The sh_entsize and sh_info fields may have been set already by
2726      copy_private_section_data.  */
2727
2728   this_hdr->bfd_section = asect;
2729   this_hdr->contents = NULL;
2730
2731   /* If the section type is unspecified, we set it based on
2732      asect->flags.  */
2733   if (this_hdr->sh_type == SHT_NULL)
2734     {
2735       if ((asect->flags & SEC_GROUP) != 0)
2736         this_hdr->sh_type = SHT_GROUP;
2737       else if ((asect->flags & SEC_ALLOC) != 0
2738           && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2739               || (asect->flags & SEC_NEVER_LOAD) != 0))
2740         this_hdr->sh_type = SHT_NOBITS;
2741       else
2742         this_hdr->sh_type = SHT_PROGBITS;
2743     }
2744
2745   switch (this_hdr->sh_type)
2746     {
2747     default:
2748       break;
2749
2750     case SHT_STRTAB:
2751     case SHT_INIT_ARRAY:
2752     case SHT_FINI_ARRAY:
2753     case SHT_PREINIT_ARRAY:
2754     case SHT_NOTE:
2755     case SHT_NOBITS:
2756     case SHT_PROGBITS:
2757       break;
2758
2759     case SHT_HASH:
2760       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2761       break;
2762
2763     case SHT_DYNSYM:
2764       this_hdr->sh_entsize = bed->s->sizeof_sym;
2765       break;
2766
2767     case SHT_DYNAMIC:
2768       this_hdr->sh_entsize = bed->s->sizeof_dyn;
2769       break;
2770
2771     case SHT_RELA:
2772       if (get_elf_backend_data (abfd)->may_use_rela_p)
2773         this_hdr->sh_entsize = bed->s->sizeof_rela;
2774       break;
2775
2776      case SHT_REL:
2777       if (get_elf_backend_data (abfd)->may_use_rel_p)
2778         this_hdr->sh_entsize = bed->s->sizeof_rel;
2779       break;
2780
2781      case SHT_GNU_versym:
2782       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2783       break;
2784
2785      case SHT_GNU_verdef:
2786       this_hdr->sh_entsize = 0;
2787       /* objcopy or strip will copy over sh_info, but may not set
2788          cverdefs.  The linker will set cverdefs, but sh_info will be
2789          zero.  */
2790       if (this_hdr->sh_info == 0)
2791         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2792       else
2793         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2794                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2795       break;
2796
2797     case SHT_GNU_verneed:
2798       this_hdr->sh_entsize = 0;
2799       /* objcopy or strip will copy over sh_info, but may not set
2800          cverrefs.  The linker will set cverrefs, but sh_info will be
2801          zero.  */
2802       if (this_hdr->sh_info == 0)
2803         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2804       else
2805         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2806                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2807       break;
2808
2809     case SHT_GROUP:
2810       this_hdr->sh_entsize = 4;
2811       break;
2812     }
2813
2814   if ((asect->flags & SEC_ALLOC) != 0)
2815     this_hdr->sh_flags |= SHF_ALLOC;
2816   if ((asect->flags & SEC_READONLY) == 0)
2817     this_hdr->sh_flags |= SHF_WRITE;
2818   if ((asect->flags & SEC_CODE) != 0)
2819     this_hdr->sh_flags |= SHF_EXECINSTR;
2820   if ((asect->flags & SEC_MERGE) != 0)
2821     {
2822       this_hdr->sh_flags |= SHF_MERGE;
2823       this_hdr->sh_entsize = asect->entsize;
2824       if ((asect->flags & SEC_STRINGS) != 0)
2825         this_hdr->sh_flags |= SHF_STRINGS;
2826     }
2827   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2828     this_hdr->sh_flags |= SHF_GROUP;
2829   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2830     {
2831       this_hdr->sh_flags |= SHF_TLS;
2832       if (asect->size == 0
2833           && (asect->flags & SEC_HAS_CONTENTS) == 0)
2834         {
2835           struct bfd_link_order *o = asect->map_tail.link_order;
2836
2837           this_hdr->sh_size = 0;
2838           if (o != NULL)
2839             {
2840               this_hdr->sh_size = o->offset + o->size;
2841               if (this_hdr->sh_size != 0)
2842                 this_hdr->sh_type = SHT_NOBITS;
2843             }
2844         }
2845     }
2846
2847   /* Check for processor-specific section types.  */
2848   if (bed->elf_backend_fake_sections
2849       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2850     *failedptr = TRUE;
2851
2852   /* If the section has relocs, set up a section header for the
2853      SHT_REL[A] section.  If two relocation sections are required for
2854      this section, it is up to the processor-specific back-end to
2855      create the other.  */
2856   if ((asect->flags & SEC_RELOC) != 0
2857       && !_bfd_elf_init_reloc_shdr (abfd,
2858                                     &elf_section_data (asect)->rel_hdr,
2859                                     asect,
2860                                     asect->use_rela_p))
2861     *failedptr = TRUE;
2862 }
2863
2864 /* Fill in the contents of a SHT_GROUP section.  */
2865
2866 void
2867 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2868 {
2869   bfd_boolean *failedptr = failedptrarg;
2870   unsigned long symindx;
2871   asection *elt, *first;
2872   unsigned char *loc;
2873   bfd_boolean gas;
2874
2875   /* Ignore linker created group section.  See elfNN_ia64_object_p in
2876      elfxx-ia64.c.  */
2877   if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2878       || *failedptr)
2879     return;
2880
2881   symindx = 0;
2882   if (elf_group_id (sec) != NULL)
2883     symindx = elf_group_id (sec)->udata.i;
2884
2885   if (symindx == 0)
2886     {
2887       /* If called from the assembler, swap_out_syms will have set up
2888          elf_section_syms;  If called for "ld -r", use target_index.  */
2889       if (elf_section_syms (abfd) != NULL)
2890         symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2891       else
2892         symindx = sec->target_index;
2893     }
2894   elf_section_data (sec)->this_hdr.sh_info = symindx;
2895
2896   /* The contents won't be allocated for "ld -r" or objcopy.  */
2897   gas = TRUE;
2898   if (sec->contents == NULL)
2899     {
2900       gas = FALSE;
2901       sec->contents = bfd_alloc (abfd, sec->size);
2902
2903       /* Arrange for the section to be written out.  */
2904       elf_section_data (sec)->this_hdr.contents = sec->contents;
2905       if (sec->contents == NULL)
2906         {
2907           *failedptr = TRUE;
2908           return;
2909         }
2910     }
2911
2912   loc = sec->contents + sec->size;
2913
2914   /* Get the pointer to the first section in the group that gas
2915      squirreled away here.  objcopy arranges for this to be set to the
2916      start of the input section group.  */
2917   first = elt = elf_next_in_group (sec);
2918
2919   /* First element is a flag word.  Rest of section is elf section
2920      indices for all the sections of the group.  Write them backwards
2921      just to keep the group in the same order as given in .section
2922      directives, not that it matters.  */
2923   while (elt != NULL)
2924     {
2925       asection *s;
2926       unsigned int idx;
2927
2928       loc -= 4;
2929       s = elt;
2930       if (!gas)
2931         s = s->output_section;
2932       idx = 0;
2933       if (s != NULL)
2934         idx = elf_section_data (s)->this_idx;
2935       H_PUT_32 (abfd, idx, loc);
2936       elt = elf_next_in_group (elt);
2937       if (elt == first)
2938         break;
2939     }
2940
2941   if ((loc -= 4) != sec->contents)
2942     abort ();
2943
2944   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2945 }
2946
2947 /* Assign all ELF section numbers.  The dummy first section is handled here
2948    too.  The link/info pointers for the standard section types are filled
2949    in here too, while we're at it.  */
2950
2951 static bfd_boolean
2952 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2953 {
2954   struct elf_obj_tdata *t = elf_tdata (abfd);
2955   asection *sec;
2956   unsigned int section_number, secn;
2957   Elf_Internal_Shdr **i_shdrp;
2958   struct bfd_elf_section_data *d;
2959
2960   section_number = 1;
2961
2962   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2963
2964   /* SHT_GROUP sections are in relocatable files only.  */
2965   if (link_info == NULL || link_info->relocatable)
2966     {
2967       /* Put SHT_GROUP sections first.  */
2968       for (sec = abfd->sections; sec != NULL; sec = sec->next)
2969         {
2970           d = elf_section_data (sec);
2971
2972           if (d->this_hdr.sh_type == SHT_GROUP)
2973             {
2974               if (sec->flags & SEC_LINKER_CREATED)
2975                 {
2976                   /* Remove the linker created SHT_GROUP sections.  */
2977                   bfd_section_list_remove (abfd, sec);
2978                   abfd->section_count--;
2979                 }
2980               else
2981                 {
2982                   if (section_number == SHN_LORESERVE)
2983                     section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2984                   d->this_idx = section_number++;
2985                 }
2986             }
2987         }
2988     }
2989
2990   for (sec = abfd->sections; sec; sec = sec->next)
2991     {
2992       d = elf_section_data (sec);
2993
2994       if (d->this_hdr.sh_type != SHT_GROUP)
2995         {
2996           if (section_number == SHN_LORESERVE)
2997             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2998           d->this_idx = section_number++;
2999         }
3000       _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
3001       if ((sec->flags & SEC_RELOC) == 0)
3002         d->rel_idx = 0;
3003       else
3004         {
3005           if (section_number == SHN_LORESERVE)
3006             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3007           d->rel_idx = section_number++;
3008           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
3009         }
3010
3011       if (d->rel_hdr2)
3012         {
3013           if (section_number == SHN_LORESERVE)
3014             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3015           d->rel_idx2 = section_number++;
3016           _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
3017         }
3018       else
3019         d->rel_idx2 = 0;
3020     }
3021
3022   if (section_number == SHN_LORESERVE)
3023     section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3024   t->shstrtab_section = section_number++;
3025   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
3026   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
3027
3028   if (bfd_get_symcount (abfd) > 0)
3029     {
3030       if (section_number == SHN_LORESERVE)
3031         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3032       t->symtab_section = section_number++;
3033       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
3034       if (section_number > SHN_LORESERVE - 2)
3035         {
3036           if (section_number == SHN_LORESERVE)
3037             section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3038           t->symtab_shndx_section = section_number++;
3039           t->symtab_shndx_hdr.sh_name
3040             = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3041                                                   ".symtab_shndx", FALSE);
3042           if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
3043             return FALSE;
3044         }
3045       if (section_number == SHN_LORESERVE)
3046         section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3047       t->strtab_section = section_number++;
3048       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
3049     }
3050
3051   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
3052   t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3053
3054   elf_numsections (abfd) = section_number;
3055   elf_elfheader (abfd)->e_shnum = section_number;
3056   if (section_number > SHN_LORESERVE)
3057     elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
3058
3059   /* Set up the list of section header pointers, in agreement with the
3060      indices.  */
3061   i_shdrp = bfd_zalloc2 (abfd, section_number, sizeof (Elf_Internal_Shdr *));
3062   if (i_shdrp == NULL)
3063     return FALSE;
3064
3065   i_shdrp[0] = bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
3066   if (i_shdrp[0] == NULL)
3067     {
3068       bfd_release (abfd, i_shdrp);
3069       return FALSE;
3070     }
3071
3072   elf_elfsections (abfd) = i_shdrp;
3073
3074   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3075   if (bfd_get_symcount (abfd) > 0)
3076     {
3077       i_shdrp[t->symtab_section] = &t->symtab_hdr;
3078       if (elf_numsections (abfd) > SHN_LORESERVE)
3079         {
3080           i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3081           t->symtab_shndx_hdr.sh_link = t->symtab_section;
3082         }
3083       i_shdrp[t->strtab_section] = &t->strtab_hdr;
3084       t->symtab_hdr.sh_link = t->strtab_section;
3085     }
3086
3087   for (sec = abfd->sections; sec; sec = sec->next)
3088     {
3089       struct bfd_elf_section_data *d = elf_section_data (sec);
3090       asection *s;
3091       const char *name;
3092
3093       i_shdrp[d->this_idx] = &d->this_hdr;
3094       if (d->rel_idx != 0)
3095         i_shdrp[d->rel_idx] = &d->rel_hdr;
3096       if (d->rel_idx2 != 0)
3097         i_shdrp[d->rel_idx2] = d->rel_hdr2;
3098
3099       /* Fill in the sh_link and sh_info fields while we're at it.  */
3100
3101       /* sh_link of a reloc section is the section index of the symbol
3102          table.  sh_info is the section index of the section to which
3103          the relocation entries apply.  */
3104       if (d->rel_idx != 0)
3105         {
3106           d->rel_hdr.sh_link = t->symtab_section;
3107           d->rel_hdr.sh_info = d->this_idx;
3108         }
3109       if (d->rel_idx2 != 0)
3110         {
3111           d->rel_hdr2->sh_link = t->symtab_section;
3112           d->rel_hdr2->sh_info = d->this_idx;
3113         }
3114
3115       /* We need to set up sh_link for SHF_LINK_ORDER.  */
3116       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3117         {
3118           s = elf_linked_to_section (sec);
3119           if (s)
3120             {
3121               /* elf_linked_to_section points to the input section.  */
3122               if (link_info != NULL)
3123                 {
3124                   /* Check discarded linkonce section.  */
3125                   if (elf_discarded_section (s))
3126                     {
3127                       asection *kept;
3128                       (*_bfd_error_handler)
3129                         (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3130                          abfd, d->this_hdr.bfd_section,
3131                          s, s->owner);
3132                       /* Point to the kept section if it has the same
3133                          size as the discarded one.  */
3134                       kept = _bfd_elf_check_kept_section (s);
3135                       if (kept == NULL)
3136                         {
3137                           bfd_set_error (bfd_error_bad_value);
3138                           return FALSE;
3139                         }
3140                       s = kept;
3141                     }
3142
3143                   s = s->output_section;
3144                   BFD_ASSERT (s != NULL);
3145                 }
3146               else
3147                 {
3148                   /* Handle objcopy. */
3149                   if (s->output_section == NULL)
3150                     {
3151                       (*_bfd_error_handler)
3152                         (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3153                          abfd, d->this_hdr.bfd_section, s, s->owner);
3154                       bfd_set_error (bfd_error_bad_value);
3155                       return FALSE;
3156                     }
3157                   s = s->output_section;
3158                 }
3159               d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3160             }
3161           else
3162             {
3163               /* PR 290:
3164                  The Intel C compiler generates SHT_IA_64_UNWIND with
3165                  SHF_LINK_ORDER.  But it doesn't set the sh_link or
3166                  sh_info fields.  Hence we could get the situation
3167                  where s is NULL.  */
3168               const struct elf_backend_data *bed
3169                 = get_elf_backend_data (abfd);
3170               if (bed->link_order_error_handler)
3171                 bed->link_order_error_handler
3172                   (_("%B: warning: sh_link not set for section `%A'"),
3173                    abfd, sec);
3174             }
3175         }
3176
3177       switch (d->this_hdr.sh_type)
3178         {
3179         case SHT_REL:
3180         case SHT_RELA:
3181           /* A reloc section which we are treating as a normal BFD
3182              section.  sh_link is the section index of the symbol
3183              table.  sh_info is the section index of the section to
3184              which the relocation entries apply.  We assume that an
3185              allocated reloc section uses the dynamic symbol table.
3186              FIXME: How can we be sure?  */
3187           s = bfd_get_section_by_name (abfd, ".dynsym");
3188           if (s != NULL)
3189             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3190
3191           /* We look up the section the relocs apply to by name.  */
3192           name = sec->name;
3193           if (d->this_hdr.sh_type == SHT_REL)
3194             name += 4;
3195           else
3196             name += 5;
3197           s = bfd_get_section_by_name (abfd, name);
3198           if (s != NULL)
3199             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3200           break;
3201
3202         case SHT_STRTAB:
3203           /* We assume that a section named .stab*str is a stabs
3204              string section.  We look for a section with the same name
3205              but without the trailing ``str'', and set its sh_link
3206              field to point to this section.  */
3207           if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
3208               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3209             {
3210               size_t len;
3211               char *alc;
3212
3213               len = strlen (sec->name);
3214               alc = bfd_malloc (len - 2);
3215               if (alc == NULL)
3216                 return FALSE;
3217               memcpy (alc, sec->name, len - 3);
3218               alc[len - 3] = '\0';
3219               s = bfd_get_section_by_name (abfd, alc);
3220               free (alc);
3221               if (s != NULL)
3222                 {
3223                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3224
3225                   /* This is a .stab section.  */
3226                   if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3227                     elf_section_data (s)->this_hdr.sh_entsize
3228                       = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3229                 }
3230             }
3231           break;
3232
3233         case SHT_DYNAMIC:
3234         case SHT_DYNSYM:
3235         case SHT_GNU_verneed:
3236         case SHT_GNU_verdef:
3237           /* sh_link is the section header index of the string table
3238              used for the dynamic entries, or the symbol table, or the
3239              version strings.  */
3240           s = bfd_get_section_by_name (abfd, ".dynstr");
3241           if (s != NULL)
3242             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3243           break;
3244
3245         case SHT_GNU_LIBLIST:
3246           /* sh_link is the section header index of the prelink library
3247              list
3248              used for the dynamic entries, or the symbol table, or the
3249              version strings.  */
3250           s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3251                                              ? ".dynstr" : ".gnu.libstr");
3252           if (s != NULL)
3253             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3254           break;
3255
3256         case SHT_HASH:
3257         case SHT_GNU_versym:
3258           /* sh_link is the section header index of the symbol table
3259              this hash table or version table is for.  */
3260           s = bfd_get_section_by_name (abfd, ".dynsym");
3261           if (s != NULL)
3262             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3263           break;
3264
3265         case SHT_GROUP:
3266           d->this_hdr.sh_link = t->symtab_section;
3267         }
3268     }
3269
3270   for (secn = 1; secn < section_number; ++secn)
3271     if (i_shdrp[secn] == NULL)
3272       i_shdrp[secn] = i_shdrp[0];
3273     else
3274       i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3275                                                        i_shdrp[secn]->sh_name);
3276   return TRUE;
3277 }
3278
3279 /* Map symbol from it's internal number to the external number, moving
3280    all local symbols to be at the head of the list.  */
3281
3282 static int
3283 sym_is_global (bfd *abfd, asymbol *sym)
3284 {
3285   /* If the backend has a special mapping, use it.  */
3286   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3287   if (bed->elf_backend_sym_is_global)
3288     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3289
3290   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3291           || bfd_is_und_section (bfd_get_section (sym))
3292           || bfd_is_com_section (bfd_get_section (sym)));
3293 }
3294
3295 static bfd_boolean
3296 elf_map_symbols (bfd *abfd)
3297 {
3298   unsigned int symcount = bfd_get_symcount (abfd);
3299   asymbol **syms = bfd_get_outsymbols (abfd);
3300   asymbol **sect_syms;
3301   unsigned int num_locals = 0;
3302   unsigned int num_globals = 0;
3303   unsigned int num_locals2 = 0;
3304   unsigned int num_globals2 = 0;
3305   int max_index = 0;
3306   unsigned int idx;
3307   asection *asect;
3308   asymbol **new_syms;
3309
3310 #ifdef DEBUG
3311   fprintf (stderr, "elf_map_symbols\n");
3312   fflush (stderr);
3313 #endif
3314
3315   for (asect = abfd->sections; asect; asect = asect->next)
3316     {
3317       if (max_index < asect->index)
3318         max_index = asect->index;
3319     }
3320
3321   max_index++;
3322   sect_syms = bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3323   if (sect_syms == NULL)
3324     return FALSE;
3325   elf_section_syms (abfd) = sect_syms;
3326   elf_num_section_syms (abfd) = max_index;
3327
3328   /* Init sect_syms entries for any section symbols we have already
3329      decided to output.  */
3330   for (idx = 0; idx < symcount; idx++)
3331     {
3332       asymbol *sym = syms[idx];
3333
3334       if ((sym->flags & BSF_SECTION_SYM) != 0
3335           && sym->value == 0)
3336         {
3337           asection *sec;
3338
3339           sec = sym->section;
3340
3341           if (sec->owner != NULL)
3342             {
3343               if (sec->owner != abfd)
3344                 {
3345                   if (sec->output_offset != 0)
3346                     continue;
3347
3348                   sec = sec->output_section;
3349
3350                   /* Empty sections in the input files may have had a
3351                      section symbol created for them.  (See the comment
3352                      near the end of _bfd_generic_link_output_symbols in
3353                      linker.c).  If the linker script discards such
3354                      sections then we will reach this point.  Since we know
3355                      that we cannot avoid this case, we detect it and skip
3356                      the abort and the assignment to the sect_syms array.
3357                      To reproduce this particular case try running the
3358                      linker testsuite test ld-scripts/weak.exp for an ELF
3359                      port that uses the generic linker.  */
3360                   if (sec->owner == NULL)
3361                     continue;
3362
3363                   BFD_ASSERT (sec->owner == abfd);
3364                 }
3365               sect_syms[sec->index] = syms[idx];
3366             }
3367         }
3368     }
3369
3370   /* Classify all of the symbols.  */
3371   for (idx = 0; idx < symcount; idx++)
3372     {
3373       if (!sym_is_global (abfd, syms[idx]))
3374         num_locals++;
3375       else
3376         num_globals++;
3377     }
3378
3379   /* We will be adding a section symbol for each BFD section.  Most normal
3380      sections will already have a section symbol in outsymbols, but
3381      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3382      at least in that case.  */
3383   for (asect = abfd->sections; asect; asect = asect->next)
3384     {
3385       if (sect_syms[asect->index] == NULL)
3386         {
3387           if (!sym_is_global (abfd, asect->symbol))
3388             num_locals++;
3389           else
3390             num_globals++;
3391         }
3392     }
3393
3394   /* Now sort the symbols so the local symbols are first.  */
3395   new_syms = bfd_alloc2 (abfd, num_locals + num_globals, sizeof (asymbol *));
3396
3397   if (new_syms == NULL)
3398     return FALSE;
3399
3400   for (idx = 0; idx < symcount; idx++)
3401     {
3402       asymbol *sym = syms[idx];
3403       unsigned int i;
3404
3405       if (!sym_is_global (abfd, sym))
3406         i = num_locals2++;
3407       else
3408         i = num_locals + num_globals2++;
3409       new_syms[i] = sym;
3410       sym->udata.i = i + 1;
3411     }
3412   for (asect = abfd->sections; asect; asect = asect->next)
3413     {
3414       if (sect_syms[asect->index] == NULL)
3415         {
3416           asymbol *sym = asect->symbol;
3417           unsigned int i;
3418
3419           sect_syms[asect->index] = sym;
3420           if (!sym_is_global (abfd, sym))
3421             i = num_locals2++;
3422           else
3423             i = num_locals + num_globals2++;
3424           new_syms[i] = sym;
3425           sym->udata.i = i + 1;
3426         }
3427     }
3428
3429   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3430
3431   elf_num_locals (abfd) = num_locals;
3432   elf_num_globals (abfd) = num_globals;
3433   return TRUE;
3434 }
3435
3436 /* Align to the maximum file alignment that could be required for any
3437    ELF data structure.  */
3438
3439 static inline file_ptr
3440 align_file_position (file_ptr off, int align)
3441 {
3442   return (off + align - 1) & ~(align - 1);
3443 }
3444
3445 /* Assign a file position to a section, optionally aligning to the
3446    required section alignment.  */
3447
3448 file_ptr
3449 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3450                                            file_ptr offset,
3451                                            bfd_boolean align)
3452 {
3453   if (align)
3454     {
3455       unsigned int al;
3456
3457       al = i_shdrp->sh_addralign;
3458       if (al > 1)
3459         offset = BFD_ALIGN (offset, al);
3460     }
3461   i_shdrp->sh_offset = offset;
3462   if (i_shdrp->bfd_section != NULL)
3463     i_shdrp->bfd_section->filepos = offset;
3464   if (i_shdrp->sh_type != SHT_NOBITS)
3465     offset += i_shdrp->sh_size;
3466   return offset;
3467 }
3468
3469 /* Compute the file positions we are going to put the sections at, and
3470    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
3471    is not NULL, this is being called by the ELF backend linker.  */
3472
3473 bfd_boolean
3474 _bfd_elf_compute_section_file_positions (bfd *abfd,
3475                                          struct bfd_link_info *link_info)
3476 {
3477   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3478   bfd_boolean failed;
3479   struct bfd_strtab_hash *strtab = NULL;
3480   Elf_Internal_Shdr *shstrtab_hdr;
3481
3482   if (abfd->output_has_begun)
3483     return TRUE;
3484
3485   /* Do any elf backend specific processing first.  */
3486   if (bed->elf_backend_begin_write_processing)
3487     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3488
3489   if (! prep_headers (abfd))
3490     return FALSE;
3491
3492   /* Post process the headers if necessary.  */
3493   if (bed->elf_backend_post_process_headers)
3494     (*bed->elf_backend_post_process_headers) (abfd, link_info);
3495
3496   failed = FALSE;
3497   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3498   if (failed)
3499     return FALSE;
3500
3501   if (!assign_section_numbers (abfd, link_info))
3502     return FALSE;
3503
3504   /* The backend linker builds symbol table information itself.  */
3505   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3506     {
3507       /* Non-zero if doing a relocatable link.  */
3508       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3509
3510       if (! swap_out_syms (abfd, &strtab, relocatable_p))
3511         return FALSE;
3512     }
3513
3514   if (link_info == NULL)
3515     {
3516       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3517       if (failed)
3518         return FALSE;
3519     }
3520
3521   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3522   /* sh_name was set in prep_headers.  */
3523   shstrtab_hdr->sh_type = SHT_STRTAB;
3524   shstrtab_hdr->sh_flags = 0;
3525   shstrtab_hdr->sh_addr = 0;
3526   shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3527   shstrtab_hdr->sh_entsize = 0;
3528   shstrtab_hdr->sh_link = 0;
3529   shstrtab_hdr->sh_info = 0;
3530   /* sh_offset is set in assign_file_positions_except_relocs.  */
3531   shstrtab_hdr->sh_addralign = 1;
3532
3533   if (!assign_file_positions_except_relocs (abfd, link_info))
3534     return FALSE;
3535
3536   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3537     {
3538       file_ptr off;
3539       Elf_Internal_Shdr *hdr;
3540
3541       off = elf_tdata (abfd)->next_file_pos;
3542
3543       hdr = &elf_tdata (abfd)->symtab_hdr;
3544       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3545
3546       hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3547       if (hdr->sh_size != 0)
3548         off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3549
3550       hdr = &elf_tdata (abfd)->strtab_hdr;
3551       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3552
3553       elf_tdata (abfd)->next_file_pos = off;
3554
3555       /* Now that we know where the .strtab section goes, write it
3556          out.  */
3557       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3558           || ! _bfd_stringtab_emit (abfd, strtab))
3559         return FALSE;
3560       _bfd_stringtab_free (strtab);
3561     }
3562
3563   abfd->output_has_begun = TRUE;
3564
3565   return TRUE;
3566 }
3567
3568 /* Create a mapping from a set of sections to a program segment.  */
3569
3570 static struct elf_segment_map *
3571 make_mapping (bfd *abfd,
3572               asection **sections,
3573               unsigned int from,
3574               unsigned int to,
3575               bfd_boolean phdr)
3576 {
3577   struct elf_segment_map *m;
3578   unsigned int i;
3579   asection **hdrpp;
3580   bfd_size_type amt;
3581
3582   amt = sizeof (struct elf_segment_map);
3583   amt += (to - from - 1) * sizeof (asection *);
3584   m = bfd_zalloc (abfd, amt);
3585   if (m == NULL)
3586     return NULL;
3587   m->next = NULL;
3588   m->p_type = PT_LOAD;
3589   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3590     m->sections[i - from] = *hdrpp;
3591   m->count = to - from;
3592
3593   if (from == 0 && phdr)
3594     {
3595       /* Include the headers in the first PT_LOAD segment.  */
3596       m->includes_filehdr = 1;
3597       m->includes_phdrs = 1;
3598     }
3599
3600   return m;
3601 }
3602
3603 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
3604    on failure.  */
3605
3606 struct elf_segment_map *
3607 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3608 {
3609   struct elf_segment_map *m;
3610
3611   m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3612   if (m == NULL)
3613     return NULL;
3614   m->next = NULL;
3615   m->p_type = PT_DYNAMIC;
3616   m->count = 1;
3617   m->sections[0] = dynsec;
3618
3619   return m;
3620 }
3621
3622 /* Set up a mapping from BFD sections to program segments.  */
3623
3624 static bfd_boolean
3625 map_sections_to_segments (bfd *abfd)
3626 {
3627   asection **sections = NULL;
3628   asection *s;
3629   unsigned int i;
3630   unsigned int count;
3631   struct elf_segment_map *mfirst;
3632   struct elf_segment_map **pm;
3633   struct elf_segment_map *m;
3634   asection *last_hdr;
3635   bfd_vma last_size;
3636   unsigned int phdr_index;
3637   bfd_vma maxpagesize;
3638   asection **hdrpp;
3639   bfd_boolean phdr_in_segment = TRUE;
3640   bfd_boolean writable;
3641   int tls_count = 0;
3642   asection *first_tls = NULL;
3643   asection *dynsec, *eh_frame_hdr;
3644   bfd_size_type amt;
3645
3646   if (elf_tdata (abfd)->segment_map != NULL)
3647     return TRUE;
3648
3649   if (bfd_count_sections (abfd) == 0)
3650     return TRUE;
3651
3652   /* Select the allocated sections, and sort them.  */
3653
3654   sections = bfd_malloc2 (bfd_count_sections (abfd), sizeof (asection *));
3655   if (sections == NULL)
3656     goto error_return;
3657
3658   i = 0;
3659   for (s = abfd->sections; s != NULL; s = s->next)
3660     {
3661       if ((s->flags & SEC_ALLOC) != 0)
3662         {
3663           sections[i] = s;
3664           ++i;
3665         }
3666     }
3667   BFD_ASSERT (i <= bfd_count_sections (abfd));
3668   count = i;
3669
3670   qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3671
3672   /* Build the mapping.  */
3673
3674   mfirst = NULL;
3675   pm = &mfirst;
3676
3677   /* If we have a .interp section, then create a PT_PHDR segment for
3678      the program headers and a PT_INTERP segment for the .interp
3679      section.  */
3680   s = bfd_get_section_by_name (abfd, ".interp");
3681   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3682     {
3683       amt = sizeof (struct elf_segment_map);
3684       m = bfd_zalloc (abfd, amt);
3685       if (m == NULL)
3686         goto error_return;
3687       m->next = NULL;
3688       m->p_type = PT_PHDR;
3689       /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
3690       m->p_flags = PF_R | PF_X;
3691       m->p_flags_valid = 1;
3692       m->includes_phdrs = 1;
3693
3694       *pm = m;
3695       pm = &m->next;
3696
3697       amt = sizeof (struct elf_segment_map);
3698       m = bfd_zalloc (abfd, amt);
3699       if (m == NULL)
3700         goto error_return;
3701       m->next = NULL;
3702       m->p_type = PT_INTERP;
3703       m->count = 1;
3704       m->sections[0] = s;
3705
3706       *pm = m;
3707       pm = &m->next;
3708     }
3709
3710   /* Look through the sections.  We put sections in the same program
3711      segment when the start of the second section can be placed within
3712      a few bytes of the end of the first section.  */
3713   last_hdr = NULL;
3714   last_size = 0;
3715   phdr_index = 0;
3716   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3717   writable = FALSE;
3718   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3719   if (dynsec != NULL
3720       && (dynsec->flags & SEC_LOAD) == 0)
3721     dynsec = NULL;
3722
3723   /* Deal with -Ttext or something similar such that the first section
3724      is not adjacent to the program headers.  This is an
3725      approximation, since at this point we don't know exactly how many
3726      program headers we will need.  */
3727   if (count > 0)
3728     {
3729       bfd_size_type phdr_size;
3730
3731       phdr_size = elf_tdata (abfd)->program_header_size;
3732       if (phdr_size == 0)
3733         phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3734       if ((abfd->flags & D_PAGED) == 0
3735           || sections[0]->lma < phdr_size
3736           || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3737         phdr_in_segment = FALSE;
3738     }
3739
3740   for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3741     {
3742       asection *hdr;
3743       bfd_boolean new_segment;
3744
3745       hdr = *hdrpp;
3746
3747       /* See if this section and the last one will fit in the same
3748          segment.  */
3749
3750       if (last_hdr == NULL)
3751         {
3752           /* If we don't have a segment yet, then we don't need a new
3753              one (we build the last one after this loop).  */
3754           new_segment = FALSE;
3755         }
3756       else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3757         {
3758           /* If this section has a different relation between the
3759              virtual address and the load address, then we need a new
3760              segment.  */
3761           new_segment = TRUE;
3762         }
3763       else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3764                < BFD_ALIGN (hdr->lma, maxpagesize))
3765         {
3766           /* If putting this section in this segment would force us to
3767              skip a page in the segment, then we need a new segment.  */
3768           new_segment = TRUE;
3769         }
3770       else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3771                && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3772         {
3773           /* We don't want to put a loadable section after a
3774              nonloadable section in the same segment.
3775              Consider .tbss sections as loadable for this purpose.  */
3776           new_segment = TRUE;
3777         }
3778       else if ((abfd->flags & D_PAGED) == 0)
3779         {
3780           /* If the file is not demand paged, which means that we
3781              don't require the sections to be correctly aligned in the
3782              file, then there is no other reason for a new segment.  */
3783           new_segment = FALSE;
3784         }
3785       else if (! writable
3786                && (hdr->flags & SEC_READONLY) == 0
3787                && (((last_hdr->lma + last_size - 1)
3788                     & ~(maxpagesize - 1))
3789                    != (hdr->lma & ~(maxpagesize - 1))))
3790         {
3791           /* We don't want to put a writable section in a read only
3792              segment, unless they are on the same page in memory
3793              anyhow.  We already know that the last section does not
3794              bring us past the current section on the page, so the
3795              only case in which the new section is not on the same
3796              page as the previous section is when the previous section
3797              ends precisely on a page boundary.  */
3798           new_segment = TRUE;
3799         }
3800       else
3801         {
3802           /* Otherwise, we can use the same segment.  */
3803           new_segment = FALSE;
3804         }
3805
3806       if (! new_segment)
3807         {
3808           if ((hdr->flags & SEC_READONLY) == 0)
3809             writable = TRUE;
3810           last_hdr = hdr;
3811           /* .tbss sections effectively have zero size.  */
3812           if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3813             last_size = hdr->size;
3814           else
3815             last_size = 0;
3816           continue;
3817         }
3818
3819       /* We need a new program segment.  We must create a new program
3820          header holding all the sections from phdr_index until hdr.  */
3821
3822       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3823       if (m == NULL)
3824         goto error_return;
3825
3826       *pm = m;
3827       pm = &m->next;
3828
3829       if ((hdr->flags & SEC_READONLY) == 0)
3830         writable = TRUE;
3831       else
3832         writable = FALSE;
3833
3834       last_hdr = hdr;
3835       /* .tbss sections effectively have zero size.  */
3836       if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3837         last_size = hdr->size;
3838       else
3839         last_size = 0;
3840       phdr_index = i;
3841       phdr_in_segment = FALSE;
3842     }
3843
3844   /* Create a final PT_LOAD program segment.  */
3845   if (last_hdr != NULL)
3846     {
3847       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3848       if (m == NULL)
3849         goto error_return;
3850
3851       *pm = m;
3852       pm = &m->next;
3853     }
3854
3855   /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
3856   if (dynsec != NULL)
3857     {
3858       m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3859       if (m == NULL)
3860         goto error_return;
3861       *pm = m;
3862       pm = &m->next;
3863     }
3864
3865   /* For each loadable .note section, add a PT_NOTE segment.  We don't
3866      use bfd_get_section_by_name, because if we link together
3867      nonloadable .note sections and loadable .note sections, we will
3868      generate two .note sections in the output file.  FIXME: Using
3869      names for section types is bogus anyhow.  */
3870   for (s = abfd->sections; s != NULL; s = s->next)
3871     {
3872       if ((s->flags & SEC_LOAD) != 0
3873           && strncmp (s->name, ".note", 5) == 0)
3874         {
3875           amt = sizeof (struct elf_segment_map);
3876           m = bfd_zalloc (abfd, amt);
3877           if (m == NULL)
3878             goto error_return;
3879           m->next = NULL;
3880           m->p_type = PT_NOTE;
3881           m->count = 1;
3882           m->sections[0] = s;
3883
3884           *pm = m;
3885           pm = &m->next;
3886         }
3887       if (s->flags & SEC_THREAD_LOCAL)
3888         {
3889           if (! tls_count)
3890             first_tls = s;
3891           tls_count++;
3892         }
3893     }
3894
3895   /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
3896   if (tls_count > 0)
3897     {
3898       int i;
3899
3900       amt = sizeof (struct elf_segment_map);
3901       amt += (tls_count - 1) * sizeof (asection *);
3902       m = bfd_zalloc (abfd, amt);
3903       if (m == NULL)
3904         goto error_return;
3905       m->next = NULL;
3906       m->p_type = PT_TLS;
3907       m->count = tls_count;
3908       /* Mandated PF_R.  */
3909       m->p_flags = PF_R;
3910       m->p_flags_valid = 1;
3911       for (i = 0; i < tls_count; ++i)
3912         {
3913           BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3914           m->sections[i] = first_tls;
3915           first_tls = first_tls->next;
3916         }
3917
3918       *pm = m;
3919       pm = &m->next;
3920     }
3921
3922   /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3923      segment.  */
3924   eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3925   if (eh_frame_hdr != NULL
3926       && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3927     {
3928       amt = sizeof (struct elf_segment_map);
3929       m = bfd_zalloc (abfd, amt);
3930       if (m == NULL)
3931         goto error_return;
3932       m->next = NULL;
3933       m->p_type = PT_GNU_EH_FRAME;
3934       m->count = 1;
3935       m->sections[0] = eh_frame_hdr->output_section;
3936
3937       *pm = m;
3938       pm = &m->next;
3939     }
3940
3941   if (elf_tdata (abfd)->stack_flags)
3942     {
3943       amt = sizeof (struct elf_segment_map);
3944       m = bfd_zalloc (abfd, amt);
3945       if (m == NULL)
3946         goto error_return;
3947       m->next = NULL;
3948       m->p_type = PT_GNU_STACK;
3949       m->p_flags = elf_tdata (abfd)->stack_flags;
3950       m->p_flags_valid = 1;
3951
3952       *pm = m;
3953       pm = &m->next;
3954     }
3955
3956   if (elf_tdata (abfd)->relro)
3957     {
3958       amt = sizeof (struct elf_segment_map);
3959       m = bfd_zalloc (abfd, amt);
3960       if (m == NULL)
3961         goto error_return;
3962       m->next = NULL;
3963       m->p_type = PT_GNU_RELRO;
3964       m->p_flags = PF_R;
3965       m->p_flags_valid = 1;
3966
3967       *pm = m;
3968       pm = &m->next;
3969     }
3970
3971   free (sections);
3972   sections = NULL;
3973
3974   elf_tdata (abfd)->segment_map = mfirst;
3975   return TRUE;
3976
3977  error_return:
3978   if (sections != NULL)
3979     free (sections);
3980   return FALSE;
3981 }
3982
3983 /* Sort sections by address.  */
3984
3985 static int
3986 elf_sort_sections (const void *arg1, const void *arg2)
3987 {
3988   const asection *sec1 = *(const asection **) arg1;
3989   const asection *sec2 = *(const asection **) arg2;
3990   bfd_size_type size1, size2;
3991
3992   /* Sort by LMA first, since this is the address used to
3993      place the section into a segment.  */
3994   if (sec1->lma < sec2->lma)
3995     return -1;
3996   else if (sec1->lma > sec2->lma)
3997     return 1;
3998
3999   /* Then sort by VMA.  Normally the LMA and the VMA will be
4000      the same, and this will do nothing.  */
4001   if (sec1->vma < sec2->vma)
4002     return -1;
4003   else if (sec1->vma > sec2->vma)
4004     return 1;
4005
4006   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
4007
4008 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4009
4010   if (TOEND (sec1))
4011     {
4012       if (TOEND (sec2))
4013         {
4014           /* If the indicies are the same, do not return 0
4015              here, but continue to try the next comparison.  */
4016           if (sec1->target_index - sec2->target_index != 0)
4017             return sec1->target_index - sec2->target_index;
4018         }
4019       else
4020         return 1;
4021     }
4022   else if (TOEND (sec2))
4023     return -1;
4024
4025 #undef TOEND
4026
4027   /* Sort by size, to put zero sized sections
4028      before others at the same address.  */
4029
4030   size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4031   size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4032
4033   if (size1 < size2)
4034     return -1;
4035   if (size1 > size2)
4036     return 1;
4037
4038   return sec1->target_index - sec2->target_index;
4039 }
4040
4041 /* Ian Lance Taylor writes:
4042
4043    We shouldn't be using % with a negative signed number.  That's just
4044    not good.  We have to make sure either that the number is not
4045    negative, or that the number has an unsigned type.  When the types
4046    are all the same size they wind up as unsigned.  When file_ptr is a
4047    larger signed type, the arithmetic winds up as signed long long,
4048    which is wrong.
4049
4050    What we're trying to say here is something like ``increase OFF by
4051    the least amount that will cause it to be equal to the VMA modulo
4052    the page size.''  */
4053 /* In other words, something like:
4054
4055    vma_offset = m->sections[0]->vma % bed->maxpagesize;
4056    off_offset = off % bed->maxpagesize;
4057    if (vma_offset < off_offset)
4058      adjustment = vma_offset + bed->maxpagesize - off_offset;
4059    else
4060      adjustment = vma_offset - off_offset;
4061
4062    which can can be collapsed into the expression below.  */
4063
4064 static file_ptr
4065 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4066 {
4067   return ((vma - off) % maxpagesize);
4068 }
4069
4070 static void
4071 print_segment_map (bfd *abfd)
4072 {
4073   struct elf_segment_map *m;
4074   unsigned int i, j;
4075
4076   fprintf (stderr, _(" Section to Segment mapping:\n"));
4077   fprintf (stderr, _("  Segment              Sections...\n"));
4078
4079   for (i= 0, m = elf_tdata (abfd)->segment_map;
4080        m != NULL;
4081        i++, m = m->next)
4082     {
4083       const char *pt = get_segment_type (m->p_type);
4084       char buf[32];
4085
4086       if (pt == NULL)
4087         {
4088           if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4089             sprintf (buf, "LOPROC+%7.7x",
4090                      (unsigned int) (m->p_type - PT_LOPROC));
4091           else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4092             sprintf (buf, "LOOS+%7.7x",
4093                      (unsigned int) (m->p_type - PT_LOOS));
4094           else
4095             snprintf (buf, sizeof (buf), "%8.8x",
4096                       (unsigned int) m->p_type);
4097           pt = buf;
4098         }
4099       fprintf (stderr, "  %2.2d: %14.14s:  ", i, pt);
4100       for (j = 0; j < m->count; j++)
4101         fprintf (stderr, "%s ", m->sections [j]->name);
4102       putc ('\n',stderr);
4103     }
4104 }
4105
4106 /* Assign file positions to the sections based on the mapping from
4107    sections to segments.  This function also sets up some fields in
4108    the file header, and writes out the program headers.  */
4109
4110 static bfd_boolean
4111 assign_file_positions_for_segments (bfd *abfd, struct bfd_link_info *link_info)
4112 {
4113   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4114   unsigned int count;
4115   struct elf_segment_map *m;
4116   unsigned int alloc;
4117   Elf_Internal_Phdr *phdrs;
4118   file_ptr off, voff;
4119   bfd_vma filehdr_vaddr, filehdr_paddr;
4120   bfd_vma phdrs_vaddr, phdrs_paddr;
4121   Elf_Internal_Phdr *p;
4122
4123   if (elf_tdata (abfd)->segment_map == NULL)
4124     {
4125       if (! map_sections_to_segments (abfd))
4126         return FALSE;
4127     }
4128   else
4129     {
4130       /* The placement algorithm assumes that non allocated sections are
4131          not in PT_LOAD segments.  We ensure this here by removing such
4132          sections from the segment map.  We also remove excluded
4133          sections.  */
4134       for (m = elf_tdata (abfd)->segment_map;
4135            m != NULL;
4136            m = m->next)
4137         {
4138           unsigned int new_count;
4139           unsigned int i;
4140
4141           new_count = 0;
4142           for (i = 0; i < m->count; i ++)
4143             {
4144               if ((m->sections[i]->flags & SEC_EXCLUDE) == 0
4145                   && ((m->sections[i]->flags & SEC_ALLOC) != 0
4146                       || m->p_type != PT_LOAD))
4147                 {
4148                   if (i != new_count)
4149                     m->sections[new_count] = m->sections[i];
4150
4151                   new_count ++;
4152                 }
4153             }
4154
4155           if (new_count != m->count)
4156             m->count = new_count;
4157         }
4158     }
4159
4160   if (bed->elf_backend_modify_segment_map)
4161     {
4162       if (! (*bed->elf_backend_modify_segment_map) (abfd, link_info))
4163         return FALSE;
4164     }
4165
4166   count = 0;
4167   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4168     ++count;
4169
4170   elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4171   elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4172   elf_elfheader (abfd)->e_phnum = count;
4173
4174   if (count == 0)
4175     {
4176       elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4177       return TRUE;
4178     }
4179
4180   /* If we already counted the number of program segments, make sure
4181      that we allocated enough space.  This happens when SIZEOF_HEADERS
4182      is used in a linker script.  */
4183   alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
4184   if (alloc != 0 && count > alloc)
4185     {
4186       ((*_bfd_error_handler)
4187        (_("%B: Not enough room for program headers (allocated %u, need %u)"),
4188         abfd, alloc, count));
4189       print_segment_map (abfd);
4190       bfd_set_error (bfd_error_bad_value);
4191       return FALSE;
4192     }
4193
4194   if (alloc == 0)
4195     alloc = count;
4196
4197   phdrs = bfd_alloc2 (abfd, alloc, sizeof (Elf_Internal_Phdr));
4198   if (phdrs == NULL)
4199     return FALSE;
4200
4201   off = bed->s->sizeof_ehdr;
4202   off += alloc * bed->s->sizeof_phdr;
4203
4204   filehdr_vaddr = 0;
4205   filehdr_paddr = 0;
4206   phdrs_vaddr = 0;
4207   phdrs_paddr = 0;
4208
4209   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4210        m != NULL;
4211        m = m->next, p++)
4212     {
4213       unsigned int i;
4214       asection **secpp;
4215
4216       /* If elf_segment_map is not from map_sections_to_segments, the
4217          sections may not be correctly ordered.  NOTE: sorting should
4218          not be done to the PT_NOTE section of a corefile, which may
4219          contain several pseudo-sections artificially created by bfd.
4220          Sorting these pseudo-sections breaks things badly.  */
4221       if (m->count > 1
4222           && !(elf_elfheader (abfd)->e_type == ET_CORE
4223                && m->p_type == PT_NOTE))
4224         qsort (m->sections, (size_t) m->count, sizeof (asection *),
4225                elf_sort_sections);
4226
4227       /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4228          number of sections with contents contributing to both p_filesz
4229          and p_memsz, followed by a number of sections with no contents
4230          that just contribute to p_memsz.  In this loop, OFF tracks next
4231          available file offset for PT_LOAD and PT_NOTE segments.  VOFF is
4232          an adjustment we use for segments that have no file contents
4233          but need zero filled memory allocation.  */
4234       voff = 0;
4235       p->p_type = m->p_type;
4236       p->p_flags = m->p_flags;
4237
4238       if (p->p_type == PT_LOAD
4239           && m->count > 0)
4240         {
4241           bfd_size_type align;
4242           bfd_vma adjust;
4243           unsigned int align_power = 0;
4244
4245           for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4246             {
4247               unsigned int secalign;
4248
4249               secalign = bfd_get_section_alignment (abfd, *secpp);
4250               if (secalign > align_power)
4251                 align_power = secalign;
4252             }
4253           align = (bfd_size_type) 1 << align_power;
4254
4255           if ((abfd->flags & D_PAGED) != 0 && bed->maxpagesize > align)
4256             align = bed->maxpagesize;
4257
4258           adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4259           off += adjust;
4260           if (adjust != 0
4261               && !m->includes_filehdr
4262               && !m->includes_phdrs
4263               && (ufile_ptr) off >= align)
4264             {
4265               /* If the first section isn't loadable, the same holds for
4266                  any other sections.  Since the segment won't need file
4267                  space, we can make p_offset overlap some prior segment.
4268                  However, .tbss is special.  If a segment starts with
4269                  .tbss, we need to look at the next section to decide
4270                  whether the segment has any loadable sections.  */
4271               i = 0;
4272               while ((m->sections[i]->flags & SEC_LOAD) == 0)
4273                 {
4274                   if ((m->sections[i]->flags & SEC_THREAD_LOCAL) == 0
4275                       || ++i >= m->count)
4276                     {
4277                       off -= adjust;
4278                       voff = adjust - align;
4279                       break;
4280                     }
4281                 }
4282             }
4283         }
4284       /* Make sure the .dynamic section is the first section in the
4285          PT_DYNAMIC segment.  */
4286       else if (p->p_type == PT_DYNAMIC
4287                && m->count > 1
4288                && strcmp (m->sections[0]->name, ".dynamic") != 0)
4289         {
4290           _bfd_error_handler
4291             (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4292              abfd);
4293           bfd_set_error (bfd_error_bad_value);
4294           return FALSE;
4295         }
4296
4297       if (m->count == 0)
4298         p->p_vaddr = 0;
4299       else
4300         p->p_vaddr = m->sections[0]->vma;
4301
4302       if (m->p_paddr_valid)
4303         p->p_paddr = m->p_paddr;
4304       else if (m->count == 0)
4305         p->p_paddr = 0;
4306       else
4307         p->p_paddr = m->sections[0]->lma;
4308
4309       if (p->p_type == PT_LOAD
4310           && (abfd->flags & D_PAGED) != 0)
4311         p->p_align = bed->maxpagesize;
4312       else if (m->count == 0)
4313         p->p_align = 1 << bed->s->log_file_align;
4314       else
4315         p->p_align = 0;
4316
4317       p->p_offset = 0;
4318       p->p_filesz = 0;
4319       p->p_memsz = 0;
4320
4321       if (m->includes_filehdr)
4322         {
4323           if (! m->p_flags_valid)
4324             p->p_flags |= PF_R;
4325           p->p_offset = 0;
4326           p->p_filesz = bed->s->sizeof_ehdr;
4327           p->p_memsz = bed->s->sizeof_ehdr;
4328           if (m->count > 0)
4329             {
4330               BFD_ASSERT (p->p_type == PT_LOAD);
4331
4332               if (p->p_vaddr < (bfd_vma) off)
4333                 {
4334                   (*_bfd_error_handler)
4335                     (_("%B: Not enough room for program headers, try linking with -N"),
4336                      abfd);
4337                   bfd_set_error (bfd_error_bad_value);
4338                   return FALSE;
4339                 }
4340
4341               p->p_vaddr -= off;
4342               if (! m->p_paddr_valid)
4343                 p->p_paddr -= off;
4344             }
4345           if (p->p_type == PT_LOAD)
4346             {
4347               filehdr_vaddr = p->p_vaddr;
4348               filehdr_paddr = p->p_paddr;
4349             }
4350         }
4351
4352       if (m->includes_phdrs)
4353         {
4354           if (! m->p_flags_valid)
4355             p->p_flags |= PF_R;
4356
4357           if (m->includes_filehdr)
4358             {
4359               if (p->p_type == PT_LOAD)
4360                 {
4361                   phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
4362                   phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
4363                 }
4364             }
4365           else
4366             {
4367               p->p_offset = bed->s->sizeof_ehdr;
4368
4369               if (m->count > 0)
4370                 {
4371                   BFD_ASSERT (p->p_type == PT_LOAD);
4372                   p->p_vaddr -= off - p->p_offset;
4373                   if (! m->p_paddr_valid)
4374                     p->p_paddr -= off - p->p_offset;
4375                 }
4376
4377               if (p->p_type == PT_LOAD)
4378                 {
4379                   phdrs_vaddr = p->p_vaddr;
4380                   phdrs_paddr = p->p_paddr;
4381                 }
4382               else
4383                 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4384             }
4385
4386           p->p_filesz += alloc * bed->s->sizeof_phdr;
4387           p->p_memsz += alloc * bed->s->sizeof_phdr;
4388         }
4389
4390       if (p->p_type == PT_LOAD
4391           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4392         {
4393           if (! m->includes_filehdr && ! m->includes_phdrs)
4394             p->p_offset = off + voff;
4395           else
4396             {
4397               file_ptr adjust;
4398
4399               adjust = off - (p->p_offset + p->p_filesz);
4400               p->p_filesz += adjust;
4401               p->p_memsz += adjust;
4402             }
4403         }
4404
4405       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4406         {
4407           asection *sec;
4408           flagword flags;
4409           bfd_size_type align;
4410
4411           sec = *secpp;
4412           flags = sec->flags;
4413           align = 1 << bfd_get_section_alignment (abfd, sec);
4414
4415           if (p->p_type == PT_LOAD
4416               || p->p_type == PT_TLS)
4417             {
4418               bfd_signed_vma adjust;
4419
4420               if ((flags & SEC_LOAD) != 0)
4421                 {
4422                   adjust = sec->lma - (p->p_paddr + p->p_filesz);
4423                   if (adjust < 0)
4424                     {
4425                       (*_bfd_error_handler)
4426                         (_("%B: section %A lma 0x%lx overlaps previous sections"),
4427                          abfd, sec, (unsigned long) sec->lma);
4428                       adjust = 0;
4429                     }
4430                   off += adjust;
4431                   p->p_filesz += adjust;
4432                   p->p_memsz += adjust;
4433                 }
4434               /* .tbss is special.  It doesn't contribute to p_memsz of
4435                  normal segments.  */
4436               else if ((flags & SEC_THREAD_LOCAL) == 0
4437                        || p->p_type == PT_TLS)
4438                 {
4439                   /* The section VMA must equal the file position
4440                      modulo the page size.  */
4441                   bfd_size_type page = align;
4442                   if ((abfd->flags & D_PAGED) != 0 && bed->maxpagesize > page)
4443                     page = bed->maxpagesize;
4444                   adjust = vma_page_aligned_bias (sec->vma,
4445                                                   p->p_vaddr + p->p_memsz,
4446                                                   page);
4447                   p->p_memsz += adjust;
4448                 }
4449             }
4450
4451           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4452             {
4453               /* The section at i == 0 is the one that actually contains
4454                  everything.  */
4455               if (i == 0)
4456                 {
4457                   sec->filepos = off;
4458                   off += sec->size;
4459                   p->p_filesz = sec->size;
4460                   p->p_memsz = 0;
4461                   p->p_align = 1;
4462                 }
4463               else
4464                 {
4465                   /* The rest are fake sections that shouldn't be written.  */
4466                   sec->filepos = 0;
4467                   sec->size = 0;
4468                   sec->flags = 0;
4469                   continue;
4470                 }
4471             }
4472           else
4473             {
4474               if (p->p_type == PT_LOAD)
4475                 {
4476                   sec->filepos = off;
4477                   /* FIXME: The SEC_HAS_CONTENTS test here dates back to
4478                      1997, and the exact reason for it isn't clear.  One
4479                      plausible explanation is that it is to work around
4480                      a problem we have with linker scripts using data
4481                      statements in NOLOAD sections.  I don't think it
4482                      makes a great deal of sense to have such a section
4483                      assigned to a PT_LOAD segment, but apparently
4484                      people do this.  The data statement results in a
4485                      bfd_data_link_order being built, and these need
4486                      section contents to write into.  Eventually, we get
4487                      to _bfd_elf_write_object_contents which writes any
4488                      section with contents to the output.  Make room
4489                      here for the write, so that following segments are
4490                      not trashed.  */
4491                   if ((flags & SEC_LOAD) != 0
4492                       || (flags & SEC_HAS_CONTENTS) != 0)
4493                     off += sec->size;
4494                 }
4495
4496               if ((flags & SEC_LOAD) != 0)
4497                 {
4498                   p->p_filesz += sec->size;
4499                   p->p_memsz += sec->size;
4500                 }
4501               /* PR ld/594:  Sections in note segments which are not loaded
4502                  contribute to the file size but not the in-memory size.  */
4503               else if (p->p_type == PT_NOTE
4504                   && (flags & SEC_HAS_CONTENTS) != 0)
4505                 p->p_filesz += sec->size;
4506
4507               /* .tbss is special.  It doesn't contribute to p_memsz of
4508                  normal segments.  */
4509               else if ((flags & SEC_THREAD_LOCAL) == 0
4510                        || p->p_type == PT_TLS)
4511                 p->p_memsz += sec->size;
4512
4513               if (p->p_type == PT_TLS
4514                   && sec->size == 0
4515                   && (sec->flags & SEC_HAS_CONTENTS) == 0)
4516                 {
4517                   struct bfd_link_order *o = sec->map_tail.link_order;
4518                   if (o != NULL)
4519                     p->p_memsz += o->offset + o->size;
4520                 }
4521
4522               if (align > p->p_align
4523                   && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
4524                 p->p_align = align;
4525             }
4526
4527           if (! m->p_flags_valid)
4528             {
4529               p->p_flags |= PF_R;
4530               if ((flags & SEC_CODE) != 0)
4531                 p->p_flags |= PF_X;
4532               if ((flags & SEC_READONLY) == 0)
4533                 p->p_flags |= PF_W;
4534             }
4535         }
4536     }
4537
4538   /* Now that we have set the section file positions, we can set up
4539      the file positions for the non PT_LOAD segments.  */
4540   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4541        m != NULL;
4542        m = m->next, p++)
4543     {
4544       if (p->p_type != PT_LOAD && m->count > 0)
4545         {
4546           BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
4547           /* If the section has not yet been assigned a file position,
4548              do so now.  The ARM BPABI requires that .dynamic section
4549              not be marked SEC_ALLOC because it is not part of any
4550              PT_LOAD segment, so it will not be processed above.  */
4551           if (p->p_type == PT_DYNAMIC && m->sections[0]->filepos == 0)
4552             {
4553               unsigned int i;
4554               Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4555
4556               i = 1;
4557               while (i_shdrpp[i]->bfd_section != m->sections[0])
4558                 ++i;
4559               off = (_bfd_elf_assign_file_position_for_section
4560                      (i_shdrpp[i], off, TRUE));
4561               p->p_filesz = m->sections[0]->size;
4562             }
4563           p->p_offset = m->sections[0]->filepos;
4564         }
4565       if (m->count == 0)
4566         {
4567           if (m->includes_filehdr)
4568             {
4569               p->p_vaddr = filehdr_vaddr;
4570               if (! m->p_paddr_valid)
4571                 p->p_paddr = filehdr_paddr;
4572             }
4573           else if (m->includes_phdrs)
4574             {
4575               p->p_vaddr = phdrs_vaddr;
4576               if (! m->p_paddr_valid)
4577                 p->p_paddr = phdrs_paddr;
4578             }
4579           else if (p->p_type == PT_GNU_RELRO)
4580             {
4581               Elf_Internal_Phdr *lp;
4582
4583               for (lp = phdrs; lp < phdrs + count; ++lp)
4584                 {
4585                   if (lp->p_type == PT_LOAD
4586                       && lp->p_vaddr <= link_info->relro_end
4587                       && lp->p_vaddr >= link_info->relro_start
4588                       && lp->p_vaddr + lp->p_filesz
4589                          >= link_info->relro_end)
4590                     break;
4591                 }
4592
4593               if (lp < phdrs + count
4594                   && link_info->relro_end > lp->p_vaddr)
4595                 {
4596                   p->p_vaddr = lp->p_vaddr;
4597                   p->p_paddr = lp->p_paddr;
4598                   p->p_offset = lp->p_offset;
4599                   p->p_filesz = link_info->relro_end - lp->p_vaddr;
4600                   p->p_memsz = p->p_filesz;
4601                   p->p_align = 1;
4602                   p->p_flags = (lp->p_flags & ~PF_W);
4603                 }
4604               else
4605                 {
4606                   memset (p, 0, sizeof *p);
4607                   p->p_type = PT_NULL;
4608                 }
4609             }
4610         }
4611     }
4612
4613   /* Clear out any program headers we allocated but did not use.  */
4614   for (; count < alloc; count++, p++)
4615     {
4616       memset (p, 0, sizeof *p);
4617       p->p_type = PT_NULL;
4618     }
4619
4620   elf_tdata (abfd)->phdr = phdrs;
4621
4622   elf_tdata (abfd)->next_file_pos = off;
4623
4624   /* Write out the program headers.  */
4625   if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4626       || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
4627     return FALSE;
4628
4629   return TRUE;
4630 }
4631
4632 /* Get the size of the program header.
4633
4634    If this is called by the linker before any of the section VMA's are set, it
4635    can't calculate the correct value for a strange memory layout.  This only
4636    happens when SIZEOF_HEADERS is used in a linker script.  In this case,
4637    SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4638    data segment (exclusive of .interp and .dynamic).
4639
4640    ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4641    will be two segments.  */
4642
4643 static bfd_size_type
4644 get_program_header_size (bfd *abfd)
4645 {
4646   size_t segs;
4647   asection *s;
4648   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4649
4650   /* We can't return a different result each time we're called.  */
4651   if (elf_tdata (abfd)->program_header_size != 0)
4652     return elf_tdata (abfd)->program_header_size;
4653
4654   if (elf_tdata (abfd)->segment_map != NULL)
4655     {
4656       struct elf_segment_map *m;
4657
4658       segs = 0;
4659       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4660         ++segs;
4661       elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4662       return elf_tdata (abfd)->program_header_size;
4663     }
4664
4665   /* Assume we will need exactly two PT_LOAD segments: one for text
4666      and one for data.  */
4667   segs = 2;
4668
4669   s = bfd_get_section_by_name (abfd, ".interp");
4670   if (s != NULL && (s->flags & SEC_LOAD) != 0)
4671     {
4672       /* If we have a loadable interpreter section, we need a
4673          PT_INTERP segment.  In this case, assume we also need a
4674          PT_PHDR segment, although that may not be true for all
4675          targets.  */
4676       segs += 2;
4677     }
4678
4679   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4680     {
4681       /* We need a PT_DYNAMIC segment.  */
4682       ++segs;
4683     }
4684
4685   if (elf_tdata (abfd)->eh_frame_hdr)
4686     {
4687       /* We need a PT_GNU_EH_FRAME segment.  */
4688       ++segs;
4689     }
4690
4691   if (elf_tdata (abfd)->stack_flags)
4692     {
4693       /* We need a PT_GNU_STACK segment.  */
4694       ++segs;
4695     }
4696
4697   if (elf_tdata (abfd)->relro)
4698     {
4699       /* We need a PT_GNU_RELRO segment.  */
4700       ++segs;
4701     }
4702
4703   for (s = abfd->sections; s != NULL; s = s->next)
4704     {
4705       if ((s->flags & SEC_LOAD) != 0
4706           && strncmp (s->name, ".note", 5) == 0)
4707         {
4708           /* We need a PT_NOTE segment.  */
4709           ++segs;
4710         }
4711     }
4712
4713   for (s = abfd->sections; s != NULL; s = s->next)
4714     {
4715       if (s->flags & SEC_THREAD_LOCAL)
4716         {
4717           /* We need a PT_TLS segment.  */
4718           ++segs;
4719           break;
4720         }
4721     }
4722
4723   /* Let the backend count up any program headers it might need.  */
4724   if (bed->elf_backend_additional_program_headers)
4725     {
4726       int a;
4727
4728       a = (*bed->elf_backend_additional_program_headers) (abfd);
4729       if (a == -1)
4730         abort ();
4731       segs += a;
4732     }
4733
4734   elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4735   return elf_tdata (abfd)->program_header_size;
4736 }
4737
4738 /* Work out the file positions of all the sections.  This is called by
4739    _bfd_elf_compute_section_file_positions.  All the section sizes and
4740    VMAs must be known before this is called.
4741
4742    Reloc sections come in two flavours: Those processed specially as
4743    "side-channel" data attached to a section to which they apply, and
4744    those that bfd doesn't process as relocations.  The latter sort are
4745    stored in a normal bfd section by bfd_section_from_shdr.   We don't
4746    consider the former sort here, unless they form part of the loadable
4747    image.  Reloc sections not assigned here will be handled later by
4748    assign_file_positions_for_relocs.
4749
4750    We also don't set the positions of the .symtab and .strtab here.  */
4751
4752 static bfd_boolean
4753 assign_file_positions_except_relocs (bfd *abfd,
4754                                      struct bfd_link_info *link_info)
4755 {
4756   struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4757   Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4758   Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4759   unsigned int num_sec = elf_numsections (abfd);
4760   file_ptr off;
4761   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4762
4763   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4764       && bfd_get_format (abfd) != bfd_core)
4765     {
4766       Elf_Internal_Shdr **hdrpp;
4767       unsigned int i;
4768
4769       /* Start after the ELF header.  */
4770       off = i_ehdrp->e_ehsize;
4771
4772       /* We are not creating an executable, which means that we are
4773          not creating a program header, and that the actual order of
4774          the sections in the file is unimportant.  */
4775       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4776         {
4777           Elf_Internal_Shdr *hdr;
4778
4779           hdr = *hdrpp;
4780           if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4781                && hdr->bfd_section == NULL)
4782               || i == tdata->symtab_section
4783               || i == tdata->symtab_shndx_section
4784               || i == tdata->strtab_section)
4785             {
4786               hdr->sh_offset = -1;
4787             }
4788           else
4789             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4790
4791           if (i == SHN_LORESERVE - 1)
4792             {
4793               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4794               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4795             }
4796         }
4797     }
4798   else
4799     {
4800       unsigned int i;
4801       Elf_Internal_Shdr **hdrpp;
4802
4803       /* Assign file positions for the loaded sections based on the
4804          assignment of sections to segments.  */
4805       if (! assign_file_positions_for_segments (abfd, link_info))
4806         return FALSE;
4807
4808       /* Assign file positions for the other sections.  */
4809
4810       off = elf_tdata (abfd)->next_file_pos;
4811       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4812         {
4813           Elf_Internal_Shdr *hdr;
4814
4815           hdr = *hdrpp;
4816           if (hdr->bfd_section != NULL
4817               && hdr->bfd_section->filepos != 0)
4818             hdr->sh_offset = hdr->bfd_section->filepos;
4819           else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4820             {
4821               ((*_bfd_error_handler)
4822                (_("%B: warning: allocated section `%s' not in segment"),
4823                 abfd,
4824                 (hdr->bfd_section == NULL
4825                  ? "*unknown*"
4826                  : hdr->bfd_section->name)));
4827               if ((abfd->flags & D_PAGED) != 0)
4828                 off += vma_page_aligned_bias (hdr->sh_addr, off,
4829                                               bed->maxpagesize);
4830               else
4831                 off += vma_page_aligned_bias (hdr->sh_addr, off,
4832                                               hdr->sh_addralign);
4833               off = _bfd_elf_assign_file_position_for_section (hdr, off,
4834                                                                FALSE);
4835             }
4836           else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4837                     && hdr->bfd_section == NULL)
4838                    || hdr == i_shdrpp[tdata->symtab_section]
4839                    || hdr == i_shdrpp[tdata->symtab_shndx_section]
4840                    || hdr == i_shdrpp[tdata->strtab_section])
4841             hdr->sh_offset = -1;
4842           else
4843             off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4844
4845           if (i == SHN_LORESERVE - 1)
4846             {
4847               i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4848               hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4849             }
4850         }
4851     }
4852
4853   /* Place the section headers.  */
4854   off = align_file_position (off, 1 << bed->s->log_file_align);
4855   i_ehdrp->e_shoff = off;
4856   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4857
4858   elf_tdata (abfd)->next_file_pos = off;
4859
4860   return TRUE;
4861 }
4862
4863 static bfd_boolean
4864 prep_headers (bfd *abfd)
4865 {
4866   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
4867   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4868   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
4869   struct elf_strtab_hash *shstrtab;
4870   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4871
4872   i_ehdrp = elf_elfheader (abfd);
4873   i_shdrp = elf_elfsections (abfd);
4874
4875   shstrtab = _bfd_elf_strtab_init ();
4876   if (shstrtab == NULL)
4877     return FALSE;
4878
4879   elf_shstrtab (abfd) = shstrtab;
4880
4881   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4882   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4883   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4884   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4885
4886   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4887   i_ehdrp->e_ident[EI_DATA] =
4888     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4889   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4890
4891   if ((abfd->flags & DYNAMIC) != 0)
4892     i_ehdrp->e_type = ET_DYN;
4893   else if ((abfd->flags & EXEC_P) != 0)
4894     i_ehdrp->e_type = ET_EXEC;
4895   else if (bfd_get_format (abfd) == bfd_core)
4896     i_ehdrp->e_type = ET_CORE;
4897   else
4898     i_ehdrp->e_type = ET_REL;
4899
4900   switch (bfd_get_arch (abfd))
4901     {
4902     case bfd_arch_unknown:
4903       i_ehdrp->e_machine = EM_NONE;
4904       break;
4905
4906       /* There used to be a long list of cases here, each one setting
4907          e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4908          in the corresponding bfd definition.  To avoid duplication,
4909          the switch was removed.  Machines that need special handling
4910          can generally do it in elf_backend_final_write_processing(),
4911          unless they need the information earlier than the final write.
4912          Such need can generally be supplied by replacing the tests for
4913          e_machine with the conditions used to determine it.  */
4914     default:
4915       i_ehdrp->e_machine = bed->elf_machine_code;
4916     }
4917
4918   i_ehdrp->e_version = bed->s->ev_current;
4919   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4920
4921   /* No program header, for now.  */
4922   i_ehdrp->e_phoff = 0;
4923   i_ehdrp->e_phentsize = 0;
4924   i_ehdrp->e_phnum = 0;
4925
4926   /* Each bfd section is section header entry.  */
4927   i_ehdrp->e_entry = bfd_get_start_address (abfd);
4928   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4929
4930   /* If we're building an executable, we'll need a program header table.  */
4931   if (abfd->flags & EXEC_P)
4932     /* It all happens later.  */
4933     ;
4934   else
4935     {
4936       i_ehdrp->e_phentsize = 0;
4937       i_phdrp = 0;
4938       i_ehdrp->e_phoff = 0;
4939     }
4940
4941   elf_tdata (abfd)->symtab_hdr.sh_name =
4942     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4943   elf_tdata (abfd)->strtab_hdr.sh_name =
4944     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4945   elf_tdata (abfd)->shstrtab_hdr.sh_name =
4946     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4947   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4948       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4949       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4950     return FALSE;
4951
4952   return TRUE;
4953 }
4954
4955 /* Assign file positions for all the reloc sections which are not part
4956    of the loadable file image.  */
4957
4958 void
4959 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4960 {
4961   file_ptr off;
4962   unsigned int i, num_sec;
4963   Elf_Internal_Shdr **shdrpp;
4964
4965   off = elf_tdata (abfd)->next_file_pos;
4966
4967   num_sec = elf_numsections (abfd);
4968   for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4969     {
4970       Elf_Internal_Shdr *shdrp;
4971
4972       shdrp = *shdrpp;
4973       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4974           && shdrp->sh_offset == -1)
4975         off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4976     }
4977
4978   elf_tdata (abfd)->next_file_pos = off;
4979 }
4980
4981 bfd_boolean
4982 _bfd_elf_write_object_contents (bfd *abfd)
4983 {
4984   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4985   Elf_Internal_Ehdr *i_ehdrp;
4986   Elf_Internal_Shdr **i_shdrp;
4987   bfd_boolean failed;
4988   unsigned int count, num_sec;
4989
4990   if (! abfd->output_has_begun
4991       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4992     return FALSE;
4993
4994   i_shdrp = elf_elfsections (abfd);
4995   i_ehdrp = elf_elfheader (abfd);
4996
4997   failed = FALSE;
4998   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4999   if (failed)
5000     return FALSE;
5001
5002   _bfd_elf_assign_file_positions_for_relocs (abfd);
5003
5004   /* After writing the headers, we need to write the sections too...  */
5005   num_sec = elf_numsections (abfd);
5006   for (count = 1; count < num_sec; count++)
5007     {
5008       if (bed->elf_backend_section_processing)
5009         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
5010       if (i_shdrp[count]->contents)
5011         {
5012           bfd_size_type amt = i_shdrp[count]->sh_size;
5013
5014           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
5015               || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
5016             return FALSE;
5017         }
5018       if (count == SHN_LORESERVE - 1)
5019         count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
5020     }
5021
5022   /* Write out the section header names.  */
5023   if (elf_shstrtab (abfd) != NULL
5024       && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
5025           || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
5026     return FALSE;
5027
5028   if (bed->elf_backend_final_write_processing)
5029     (*bed->elf_backend_final_write_processing) (abfd,
5030                                                 elf_tdata (abfd)->linker);
5031
5032   return bed->s->write_shdrs_and_ehdr (abfd);
5033 }
5034
5035 bfd_boolean
5036 _bfd_elf_write_corefile_contents (bfd *abfd)
5037 {
5038   /* Hopefully this can be done just like an object file.  */
5039   return _bfd_elf_write_object_contents (abfd);
5040 }
5041
5042 /* Given a section, search the header to find them.  */
5043
5044 int
5045 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
5046 {
5047   const struct elf_backend_data *bed;
5048   int index;
5049
5050   if (elf_section_data (asect) != NULL
5051       && elf_section_data (asect)->this_idx != 0)
5052     return elf_section_data (asect)->this_idx;
5053
5054   if (bfd_is_abs_section (asect))
5055     index = SHN_ABS;
5056   else if (bfd_is_com_section (asect))
5057     index = SHN_COMMON;
5058   else if (bfd_is_und_section (asect))
5059     index = SHN_UNDEF;
5060   else
5061     index = -1;
5062
5063   bed = get_elf_backend_data (abfd);
5064   if (bed->elf_backend_section_from_bfd_section)
5065     {
5066       int retval = index;
5067
5068       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5069         return retval;
5070     }
5071
5072   if (index == -1)
5073     bfd_set_error (bfd_error_nonrepresentable_section);
5074
5075   return index;
5076 }
5077
5078 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5079    on error.  */
5080
5081 int
5082 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
5083 {
5084   asymbol *asym_ptr = *asym_ptr_ptr;
5085   int idx;
5086   flagword flags = asym_ptr->flags;
5087
5088   /* When gas creates relocations against local labels, it creates its
5089      own symbol for the section, but does put the symbol into the
5090      symbol chain, so udata is 0.  When the linker is generating
5091      relocatable output, this section symbol may be for one of the
5092      input sections rather than the output section.  */
5093   if (asym_ptr->udata.i == 0
5094       && (flags & BSF_SECTION_SYM)
5095       && asym_ptr->section)
5096     {
5097       int indx;
5098
5099       if (asym_ptr->section->output_section != NULL)
5100         indx = asym_ptr->section->output_section->index;
5101       else
5102         indx = asym_ptr->section->index;
5103       if (indx < elf_num_section_syms (abfd)
5104           && elf_section_syms (abfd)[indx] != NULL)
5105         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5106     }
5107
5108   idx = asym_ptr->udata.i;
5109
5110   if (idx == 0)
5111     {
5112       /* This case can occur when using --strip-symbol on a symbol
5113          which is used in a relocation entry.  */
5114       (*_bfd_error_handler)
5115         (_("%B: symbol `%s' required but not present"),
5116          abfd, bfd_asymbol_name (asym_ptr));
5117       bfd_set_error (bfd_error_no_symbols);
5118       return -1;
5119     }
5120
5121 #if DEBUG & 4
5122   {
5123     fprintf (stderr,
5124              "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5125              (long) asym_ptr, asym_ptr->name, idx, flags,
5126              elf_symbol_flags (flags));
5127     fflush (stderr);
5128   }
5129 #endif
5130
5131   return idx;
5132 }
5133
5134 /* Rewrite program header information.  */
5135
5136 static bfd_boolean
5137 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5138 {
5139   Elf_Internal_Ehdr *iehdr;
5140   struct elf_segment_map *map;
5141   struct elf_segment_map *map_first;
5142   struct elf_segment_map **pointer_to_map;
5143   Elf_Internal_Phdr *segment;
5144   asection *section;
5145   unsigned int i;
5146   unsigned int num_segments;
5147   bfd_boolean phdr_included = FALSE;
5148   bfd_vma maxpagesize;
5149   struct elf_segment_map *phdr_adjust_seg = NULL;
5150   unsigned int phdr_adjust_num = 0;
5151   const struct elf_backend_data *bed;
5152
5153   bed = get_elf_backend_data (ibfd);
5154   iehdr = elf_elfheader (ibfd);
5155
5156   map_first = NULL;
5157   pointer_to_map = &map_first;
5158
5159   num_segments = elf_elfheader (ibfd)->e_phnum;
5160   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5161
5162   /* Returns the end address of the segment + 1.  */
5163 #define SEGMENT_END(segment, start)                                     \
5164   (start + (segment->p_memsz > segment->p_filesz                        \
5165             ? segment->p_memsz : segment->p_filesz))
5166
5167 #define SECTION_SIZE(section, segment)                                  \
5168   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))            \
5169     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)                   \
5170    ? section->size : 0)
5171
5172   /* Returns TRUE if the given section is contained within
5173      the given segment.  VMA addresses are compared.  */
5174 #define IS_CONTAINED_BY_VMA(section, segment)                           \
5175   (section->vma >= segment->p_vaddr                                     \
5176    && (section->vma + SECTION_SIZE (section, segment)                   \
5177        <= (SEGMENT_END (segment, segment->p_vaddr))))
5178
5179   /* Returns TRUE if the given section is contained within
5180      the given segment.  LMA addresses are compared.  */
5181 #define IS_CONTAINED_BY_LMA(section, segment, base)                     \
5182   (section->lma >= base                                                 \
5183    && (section->lma + SECTION_SIZE (section, segment)                   \
5184        <= SEGMENT_END (segment, base)))
5185
5186   /* Special case: corefile "NOTE" section containing regs, prpsinfo etc.  */
5187 #define IS_COREFILE_NOTE(p, s)                                          \
5188   (p->p_type == PT_NOTE                                                 \
5189    && bfd_get_format (ibfd) == bfd_core                                 \
5190    && s->vma == 0 && s->lma == 0                                        \
5191    && (bfd_vma) s->filepos >= p->p_offset                               \
5192    && ((bfd_vma) s->filepos + s->size                           \
5193        <= p->p_offset + p->p_filesz))
5194
5195   /* The complicated case when p_vaddr is 0 is to handle the Solaris
5196      linker, which generates a PT_INTERP section with p_vaddr and
5197      p_memsz set to 0.  */
5198 #define IS_SOLARIS_PT_INTERP(p, s)                                      \
5199   (p->p_vaddr == 0                                                      \
5200    && p->p_paddr == 0                                                   \
5201    && p->p_memsz == 0                                                   \
5202    && p->p_filesz > 0                                                   \
5203    && (s->flags & SEC_HAS_CONTENTS) != 0                                \
5204    && s->size > 0                                                       \
5205    && (bfd_vma) s->filepos >= p->p_offset                               \
5206    && ((bfd_vma) s->filepos + s->size                           \
5207        <= p->p_offset + p->p_filesz))
5208
5209   /* Decide if the given section should be included in the given segment.
5210      A section will be included if:
5211        1. It is within the address space of the segment -- we use the LMA
5212           if that is set for the segment and the VMA otherwise,
5213        2. It is an allocated segment,
5214        3. There is an output section associated with it,
5215        4. The section has not already been allocated to a previous segment.
5216        5. PT_GNU_STACK segments do not include any sections.
5217        6. PT_TLS segment includes only SHF_TLS sections.
5218        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5219        8. PT_DYNAMIC should not contain empty sections at the beginning
5220           (with the possible exception of .dynamic).  */
5221 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)               \
5222   ((((segment->p_paddr                                                  \
5223       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)        \
5224       : IS_CONTAINED_BY_VMA (section, segment))                         \
5225      && (section->flags & SEC_ALLOC) != 0)                              \
5226     || IS_COREFILE_NOTE (segment, section))                             \
5227    && section->output_section != NULL                                   \
5228    && segment->p_type != PT_GNU_STACK                                   \
5229    && (segment->p_type != PT_TLS                                        \
5230        || (section->flags & SEC_THREAD_LOCAL))                          \
5231    && (segment->p_type == PT_LOAD                                       \
5232        || segment->p_type == PT_TLS                                     \
5233        || (section->flags & SEC_THREAD_LOCAL) == 0)                     \
5234    && (segment->p_type != PT_DYNAMIC                                    \
5235        || SECTION_SIZE (section, segment) > 0                           \
5236        || (segment->p_paddr                                             \
5237            ? segment->p_paddr != section->lma                           \
5238            : segment->p_vaddr != section->vma)                          \
5239        || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic")    \
5240            == 0))                                                       \
5241    && ! section->segment_mark)
5242
5243   /* Returns TRUE iff seg1 starts after the end of seg2.  */
5244 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)                        \
5245   (seg1->field >= SEGMENT_END (seg2, seg2->field))
5246
5247   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5248      their VMA address ranges and their LMA address ranges overlap.
5249      It is possible to have overlapping VMA ranges without overlapping LMA
5250      ranges.  RedBoot images for example can have both .data and .bss mapped
5251      to the same VMA range, but with the .data section mapped to a different
5252      LMA.  */
5253 #define SEGMENT_OVERLAPS(seg1, seg2)                                    \
5254   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)                     \
5255         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))                 \
5256    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)                     \
5257         || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5258
5259   /* Initialise the segment mark field.  */
5260   for (section = ibfd->sections; section != NULL; section = section->next)
5261     section->segment_mark = FALSE;
5262
5263   /* Scan through the segments specified in the program header
5264      of the input BFD.  For this first scan we look for overlaps
5265      in the loadable segments.  These can be created by weird
5266      parameters to objcopy.  Also, fix some solaris weirdness.  */
5267   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5268        i < num_segments;
5269        i++, segment++)
5270     {
5271       unsigned int j;
5272       Elf_Internal_Phdr *segment2;
5273
5274       if (segment->p_type == PT_INTERP)
5275         for (section = ibfd->sections; section; section = section->next)
5276           if (IS_SOLARIS_PT_INTERP (segment, section))
5277             {
5278               /* Mininal change so that the normal section to segment
5279                  assignment code will work.  */
5280               segment->p_vaddr = section->vma;
5281               break;
5282             }
5283
5284       if (segment->p_type != PT_LOAD)
5285         continue;
5286
5287       /* Determine if this segment overlaps any previous segments.  */
5288       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
5289         {
5290           bfd_signed_vma extra_length;
5291
5292           if (segment2->p_type != PT_LOAD
5293               || ! SEGMENT_OVERLAPS (segment, segment2))
5294             continue;
5295
5296           /* Merge the two segments together.  */
5297           if (segment2->p_vaddr < segment->p_vaddr)
5298             {
5299               /* Extend SEGMENT2 to include SEGMENT and then delete
5300                  SEGMENT.  */
5301               extra_length =
5302                 SEGMENT_END (segment, segment->p_vaddr)
5303                 - SEGMENT_END (segment2, segment2->p_vaddr);
5304
5305               if (extra_length > 0)
5306                 {
5307                   segment2->p_memsz  += extra_length;
5308                   segment2->p_filesz += extra_length;
5309                 }
5310
5311               segment->p_type = PT_NULL;
5312
5313               /* Since we have deleted P we must restart the outer loop.  */
5314               i = 0;
5315               segment = elf_tdata (ibfd)->phdr;
5316               break;
5317             }
5318           else
5319             {
5320               /* Extend SEGMENT to include SEGMENT2 and then delete
5321                  SEGMENT2.  */
5322               extra_length =
5323                 SEGMENT_END (segment2, segment2->p_vaddr)
5324                 - SEGMENT_END (segment, segment->p_vaddr);
5325
5326               if (extra_length > 0)
5327                 {
5328                   segment->p_memsz  += extra_length;
5329                   segment->p_filesz += extra_length;
5330                 }
5331
5332               segment2->p_type = PT_NULL;
5333             }
5334         }
5335     }
5336
5337   /* The second scan attempts to assign sections to segments.  */
5338   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5339        i < num_segments;
5340        i ++, segment ++)
5341     {
5342       unsigned int  section_count;
5343       asection **   sections;
5344       asection *    output_section;
5345       unsigned int  isec;
5346       bfd_vma       matching_lma;
5347       bfd_vma       suggested_lma;
5348       unsigned int  j;
5349       bfd_size_type amt;
5350
5351       if (segment->p_type == PT_NULL)
5352         continue;
5353
5354       /* Compute how many sections might be placed into this segment.  */
5355       for (section = ibfd->sections, section_count = 0;
5356            section != NULL;
5357            section = section->next)
5358         if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5359           ++section_count;
5360
5361       /* Allocate a segment map big enough to contain
5362          all of the sections we have selected.  */
5363       amt = sizeof (struct elf_segment_map);
5364       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5365       map = bfd_alloc (obfd, amt);
5366       if (map == NULL)
5367         return FALSE;
5368
5369       /* Initialise the fields of the segment map.  Default to
5370          using the physical address of the segment in the input BFD.  */
5371       map->next          = NULL;
5372       map->p_type        = segment->p_type;
5373       map->p_flags       = segment->p_flags;
5374       map->p_flags_valid = 1;
5375       map->p_paddr       = segment->p_paddr;
5376       map->p_paddr_valid = 1;
5377
5378       /* Determine if this segment contains the ELF file header
5379          and if it contains the program headers themselves.  */
5380       map->includes_filehdr = (segment->p_offset == 0
5381                                && segment->p_filesz >= iehdr->e_ehsize);
5382
5383       map->includes_phdrs = 0;
5384
5385       if (! phdr_included || segment->p_type != PT_LOAD)
5386         {
5387           map->includes_phdrs =
5388             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5389              && (segment->p_offset + segment->p_filesz
5390                  >= ((bfd_vma) iehdr->e_phoff
5391                      + iehdr->e_phnum * iehdr->e_phentsize)));
5392
5393           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5394             phdr_included = TRUE;
5395         }
5396
5397       if (section_count == 0)
5398         {
5399           /* Special segments, such as the PT_PHDR segment, may contain
5400              no sections, but ordinary, loadable segments should contain
5401              something.  They are allowed by the ELF spec however, so only
5402              a warning is produced.  */
5403           if (segment->p_type == PT_LOAD)
5404             (*_bfd_error_handler)
5405               (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5406                ibfd);
5407
5408           map->count = 0;
5409           *pointer_to_map = map;
5410           pointer_to_map = &map->next;
5411
5412           continue;
5413         }
5414
5415       /* Now scan the sections in the input BFD again and attempt
5416          to add their corresponding output sections to the segment map.
5417          The problem here is how to handle an output section which has
5418          been moved (ie had its LMA changed).  There are four possibilities:
5419
5420          1. None of the sections have been moved.
5421             In this case we can continue to use the segment LMA from the
5422             input BFD.
5423
5424          2. All of the sections have been moved by the same amount.
5425             In this case we can change the segment's LMA to match the LMA
5426             of the first section.
5427
5428          3. Some of the sections have been moved, others have not.
5429             In this case those sections which have not been moved can be
5430             placed in the current segment which will have to have its size,
5431             and possibly its LMA changed, and a new segment or segments will
5432             have to be created to contain the other sections.
5433
5434          4. The sections have been moved, but not by the same amount.
5435             In this case we can change the segment's LMA to match the LMA
5436             of the first section and we will have to create a new segment
5437             or segments to contain the other sections.
5438
5439          In order to save time, we allocate an array to hold the section
5440          pointers that we are interested in.  As these sections get assigned
5441          to a segment, they are removed from this array.  */
5442
5443       /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5444          to work around this long long bug.  */
5445       sections = bfd_malloc2 (section_count, sizeof (asection *));
5446       if (sections == NULL)
5447         return FALSE;
5448
5449       /* Step One: Scan for segment vs section LMA conflicts.
5450          Also add the sections to the section array allocated above.
5451          Also add the sections to the current segment.  In the common
5452          case, where the sections have not been moved, this means that
5453          we have completely filled the segment, and there is nothing
5454          more to do.  */
5455       isec = 0;
5456       matching_lma = 0;
5457       suggested_lma = 0;
5458
5459       for (j = 0, section = ibfd->sections;
5460            section != NULL;
5461            section = section->next)
5462         {
5463           if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5464             {
5465               output_section = section->output_section;
5466
5467               sections[j ++] = section;
5468
5469               /* The Solaris native linker always sets p_paddr to 0.
5470                  We try to catch that case here, and set it to the
5471                  correct value.  Note - some backends require that
5472                  p_paddr be left as zero.  */
5473               if (segment->p_paddr == 0
5474                   && segment->p_vaddr != 0
5475                   && (! bed->want_p_paddr_set_to_zero)
5476                   && isec == 0
5477                   && output_section->lma != 0
5478                   && (output_section->vma == (segment->p_vaddr
5479                                               + (map->includes_filehdr
5480                                                  ? iehdr->e_ehsize
5481                                                  : 0)
5482                                               + (map->includes_phdrs
5483                                                  ? (iehdr->e_phnum
5484                                                     * iehdr->e_phentsize)
5485                                                  : 0))))
5486                 map->p_paddr = segment->p_vaddr;
5487
5488               /* Match up the physical address of the segment with the
5489                  LMA address of the output section.  */
5490               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5491                   || IS_COREFILE_NOTE (segment, section)
5492                   || (bed->want_p_paddr_set_to_zero &&
5493                       IS_CONTAINED_BY_VMA (output_section, segment))
5494                 )
5495                 {
5496                   if (matching_lma == 0)
5497                     matching_lma = output_section->lma;
5498
5499                   /* We assume that if the section fits within the segment
5500                      then it does not overlap any other section within that
5501                      segment.  */
5502                   map->sections[isec ++] = output_section;
5503                 }
5504               else if (suggested_lma == 0)
5505                 suggested_lma = output_section->lma;
5506             }
5507         }
5508
5509       BFD_ASSERT (j == section_count);
5510
5511       /* Step Two: Adjust the physical address of the current segment,
5512          if necessary.  */
5513       if (isec == section_count)
5514         {
5515           /* All of the sections fitted within the segment as currently
5516              specified.  This is the default case.  Add the segment to
5517              the list of built segments and carry on to process the next
5518              program header in the input BFD.  */
5519           map->count = section_count;
5520           *pointer_to_map = map;
5521           pointer_to_map = &map->next;
5522
5523           free (sections);
5524           continue;
5525         }
5526       else
5527         {
5528           if (matching_lma != 0)
5529             {
5530               /* At least one section fits inside the current segment.
5531                  Keep it, but modify its physical address to match the
5532                  LMA of the first section that fitted.  */
5533               map->p_paddr = matching_lma;
5534             }
5535           else
5536             {
5537               /* None of the sections fitted inside the current segment.
5538                  Change the current segment's physical address to match
5539                  the LMA of the first section.  */
5540               map->p_paddr = suggested_lma;
5541             }
5542
5543           /* Offset the segment physical address from the lma
5544              to allow for space taken up by elf headers.  */
5545           if (map->includes_filehdr)
5546             map->p_paddr -= iehdr->e_ehsize;
5547
5548           if (map->includes_phdrs)
5549             {
5550               map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5551
5552               /* iehdr->e_phnum is just an estimate of the number
5553                  of program headers that we will need.  Make a note
5554                  here of the number we used and the segment we chose
5555                  to hold these headers, so that we can adjust the
5556                  offset when we know the correct value.  */
5557               phdr_adjust_num = iehdr->e_phnum;
5558               phdr_adjust_seg = map;
5559             }
5560         }
5561
5562       /* Step Three: Loop over the sections again, this time assigning
5563          those that fit to the current segment and removing them from the
5564          sections array; but making sure not to leave large gaps.  Once all
5565          possible sections have been assigned to the current segment it is
5566          added to the list of built segments and if sections still remain
5567          to be assigned, a new segment is constructed before repeating
5568          the loop.  */
5569       isec = 0;
5570       do
5571         {
5572           map->count = 0;
5573           suggested_lma = 0;
5574
5575           /* Fill the current segment with sections that fit.  */
5576           for (j = 0; j < section_count; j++)
5577             {
5578               section = sections[j];
5579
5580               if (section == NULL)
5581                 continue;
5582
5583               output_section = section->output_section;
5584
5585               BFD_ASSERT (output_section != NULL);
5586
5587               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5588                   || IS_COREFILE_NOTE (segment, section))
5589                 {
5590                   if (map->count == 0)
5591                     {
5592                       /* If the first section in a segment does not start at
5593                          the beginning of the segment, then something is
5594                          wrong.  */
5595                       if (output_section->lma !=
5596                           (map->p_paddr
5597                            + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5598                            + (map->includes_phdrs
5599                               ? iehdr->e_phnum * iehdr->e_phentsize
5600                               : 0)))
5601                         abort ();
5602                     }
5603                   else
5604                     {
5605                       asection * prev_sec;
5606
5607                       prev_sec = map->sections[map->count - 1];
5608
5609                       /* If the gap between the end of the previous section
5610                          and the start of this section is more than
5611                          maxpagesize then we need to start a new segment.  */
5612                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5613                                       maxpagesize)
5614                            < BFD_ALIGN (output_section->lma, maxpagesize))
5615                           || ((prev_sec->lma + prev_sec->size)
5616                               > output_section->lma))
5617                         {
5618                           if (suggested_lma == 0)
5619                             suggested_lma = output_section->lma;
5620
5621                           continue;
5622                         }
5623                     }
5624
5625                   map->sections[map->count++] = output_section;
5626                   ++isec;
5627                   sections[j] = NULL;
5628                   section->segment_mark = TRUE;
5629                 }
5630               else if (suggested_lma == 0)
5631                 suggested_lma = output_section->lma;
5632             }
5633
5634           BFD_ASSERT (map->count > 0);
5635
5636           /* Add the current segment to the list of built segments.  */
5637           *pointer_to_map = map;
5638           pointer_to_map = &map->next;
5639
5640           if (isec < section_count)
5641             {
5642               /* We still have not allocated all of the sections to
5643                  segments.  Create a new segment here, initialise it
5644                  and carry on looping.  */
5645               amt = sizeof (struct elf_segment_map);
5646               amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5647               map = bfd_alloc (obfd, amt);
5648               if (map == NULL)
5649                 {
5650                   free (sections);
5651                   return FALSE;
5652                 }
5653
5654               /* Initialise the fields of the segment map.  Set the physical
5655                  physical address to the LMA of the first section that has
5656                  not yet been assigned.  */
5657               map->next             = NULL;
5658               map->p_type           = segment->p_type;
5659               map->p_flags          = segment->p_flags;
5660               map->p_flags_valid    = 1;
5661               map->p_paddr          = suggested_lma;
5662               map->p_paddr_valid    = 1;
5663               map->includes_filehdr = 0;
5664               map->includes_phdrs   = 0;
5665             }
5666         }
5667       while (isec < section_count);
5668
5669       free (sections);
5670     }
5671
5672   /* The Solaris linker creates program headers in which all the
5673      p_paddr fields are zero.  When we try to objcopy or strip such a
5674      file, we get confused.  Check for this case, and if we find it
5675      reset the p_paddr_valid fields.  */
5676   for (map = map_first; map != NULL; map = map->next)
5677     if (map->p_paddr != 0)
5678       break;
5679   if (map == NULL)
5680     for (map = map_first; map != NULL; map = map->next)
5681       map->p_paddr_valid = 0;
5682
5683   elf_tdata (obfd)->segment_map = map_first;
5684
5685   /* If we had to estimate the number of program headers that were
5686      going to be needed, then check our estimate now and adjust
5687      the offset if necessary.  */
5688   if (phdr_adjust_seg != NULL)
5689     {
5690       unsigned int count;
5691
5692       for (count = 0, map = map_first; map != NULL; map = map->next)
5693         count++;
5694
5695       if (count > phdr_adjust_num)
5696         phdr_adjust_seg->p_paddr
5697           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5698     }
5699
5700 #undef SEGMENT_END
5701 #undef SECTION_SIZE
5702 #undef IS_CONTAINED_BY_VMA
5703 #undef IS_CONTAINED_BY_LMA
5704 #undef IS_COREFILE_NOTE
5705 #undef IS_SOLARIS_PT_INTERP
5706 #undef INCLUDE_SECTION_IN_SEGMENT
5707 #undef SEGMENT_AFTER_SEGMENT
5708 #undef SEGMENT_OVERLAPS
5709   return TRUE;
5710 }
5711
5712 /* Copy ELF program header information.  */
5713
5714 static bfd_boolean
5715 copy_elf_program_header (bfd *ibfd, bfd *obfd)
5716 {
5717   Elf_Internal_Ehdr *iehdr;
5718   struct elf_segment_map *map;
5719   struct elf_segment_map *map_first;
5720   struct elf_segment_map **pointer_to_map;
5721   Elf_Internal_Phdr *segment;
5722   unsigned int i;
5723   unsigned int num_segments;
5724   bfd_boolean phdr_included = FALSE;
5725
5726   iehdr = elf_elfheader (ibfd);
5727
5728   map_first = NULL;
5729   pointer_to_map = &map_first;
5730
5731   num_segments = elf_elfheader (ibfd)->e_phnum;
5732   for (i = 0, segment = elf_tdata (ibfd)->phdr;
5733        i < num_segments;
5734        i++, segment++)
5735     {
5736       asection *section;
5737       unsigned int section_count;
5738       bfd_size_type amt;
5739       Elf_Internal_Shdr *this_hdr;
5740
5741       /* FIXME: Do we need to copy PT_NULL segment?  */
5742       if (segment->p_type == PT_NULL)
5743         continue;
5744
5745       /* Compute how many sections are in this segment.  */
5746       for (section = ibfd->sections, section_count = 0;
5747            section != NULL;
5748            section = section->next)
5749         {
5750           this_hdr = &(elf_section_data(section)->this_hdr);
5751           if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5752             section_count++;
5753         }
5754
5755       /* Allocate a segment map big enough to contain
5756          all of the sections we have selected.  */
5757       amt = sizeof (struct elf_segment_map);
5758       if (section_count != 0)
5759         amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5760       map = bfd_alloc (obfd, amt);
5761       if (map == NULL)
5762         return FALSE;
5763
5764       /* Initialize the fields of the output segment map with the
5765          input segment.  */
5766       map->next = NULL;
5767       map->p_type = segment->p_type;
5768       map->p_flags = segment->p_flags;
5769       map->p_flags_valid = 1;
5770       map->p_paddr = segment->p_paddr;
5771       map->p_paddr_valid = 1;
5772
5773       /* Determine if this segment contains the ELF file header
5774          and if it contains the program headers themselves.  */
5775       map->includes_filehdr = (segment->p_offset == 0
5776                                && segment->p_filesz >= iehdr->e_ehsize);
5777
5778       map->includes_phdrs = 0;
5779       if (! phdr_included || segment->p_type != PT_LOAD)
5780         {
5781           map->includes_phdrs =
5782             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5783              && (segment->p_offset + segment->p_filesz
5784                  >= ((bfd_vma) iehdr->e_phoff
5785                      + iehdr->e_phnum * iehdr->e_phentsize)));
5786
5787           if (segment->p_type == PT_LOAD && map->includes_phdrs)
5788             phdr_included = TRUE;
5789         }
5790
5791       if (section_count != 0)
5792         {
5793           unsigned int isec = 0;
5794
5795           for (section = ibfd->sections;
5796                section != NULL;
5797                section = section->next)
5798             {
5799               this_hdr = &(elf_section_data(section)->this_hdr);
5800               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5801                 map->sections[isec++] = section->output_section;
5802             }
5803         }
5804
5805       map->count = section_count;
5806       *pointer_to_map = map;
5807       pointer_to_map = &map->next;
5808     }
5809
5810   elf_tdata (obfd)->segment_map = map_first;
5811   return TRUE;
5812 }
5813
5814 /* Copy private BFD data.  This copies or rewrites ELF program header
5815    information.  */
5816
5817 static bfd_boolean
5818 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5819 {
5820   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5821       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5822     return TRUE;
5823
5824   if (elf_tdata (ibfd)->phdr == NULL)
5825     return TRUE;
5826
5827   if (ibfd->xvec == obfd->xvec)
5828     {
5829       /* Check if any sections in the input BFD covered by ELF program
5830          header are changed.  */
5831       Elf_Internal_Phdr *segment;
5832       asection *section, *osec;
5833       unsigned int i, num_segments;
5834       Elf_Internal_Shdr *this_hdr;
5835
5836       /* Initialize the segment mark field.  */
5837       for (section = obfd->sections; section != NULL;
5838            section = section->next)
5839         section->segment_mark = FALSE;
5840
5841       num_segments = elf_elfheader (ibfd)->e_phnum;
5842       for (i = 0, segment = elf_tdata (ibfd)->phdr;
5843            i < num_segments;
5844            i++, segment++)
5845         {
5846           for (section = ibfd->sections;
5847                section != NULL; section = section->next)
5848             {
5849               /* We mark the output section so that we know it comes
5850                  from the input BFD.  */
5851               osec = section->output_section;
5852               if (osec)
5853                 osec->segment_mark = TRUE;
5854
5855               /* Check if this section is covered by the segment.  */
5856               this_hdr = &(elf_section_data(section)->this_hdr);
5857               if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5858                 {
5859                   /* FIXME: Check if its output section is changed or
5860                      removed.  What else do we need to check?  */
5861                   if (osec == NULL
5862                       || section->flags != osec->flags
5863                       || section->lma != osec->lma
5864                       || section->vma != osec->vma
5865                       || section->size != osec->size
5866                       || section->rawsize != osec->rawsize
5867                       || section->alignment_power != osec->alignment_power)
5868                     goto rewrite;
5869                 }
5870             }
5871         }
5872
5873       /* Check to see if any output section doesn't come from the
5874          input BFD.  */
5875       for (section = obfd->sections; section != NULL;
5876            section = section->next)
5877         {
5878           if (section->segment_mark == FALSE)
5879             goto rewrite;
5880           else
5881             section->segment_mark = FALSE;
5882         }
5883
5884       return copy_elf_program_header (ibfd, obfd);
5885     }
5886
5887 rewrite:
5888   return rewrite_elf_program_header (ibfd, obfd);
5889 }
5890
5891 /* Initialize private output section information from input section.  */
5892
5893 bfd_boolean
5894 _bfd_elf_init_private_section_data (bfd *ibfd,
5895                                     asection *isec,
5896                                     bfd *obfd,
5897                                     asection *osec,
5898                                     struct bfd_link_info *link_info)
5899
5900 {
5901   Elf_Internal_Shdr *ihdr, *ohdr;
5902   bfd_boolean need_group = link_info == NULL || link_info->relocatable;
5903
5904   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5905       || obfd->xvec->flavour != bfd_target_elf_flavour)
5906     return TRUE;
5907
5908   /* FIXME: What if the output ELF section type has been set to
5909      something different?  */
5910   if (elf_section_type (osec) == SHT_NULL)
5911     elf_section_type (osec) = elf_section_type (isec);
5912
5913   /* Set things up for objcopy and relocatable link.  The output
5914      SHT_GROUP section will have its elf_next_in_group pointing back
5915      to the input group members.  Ignore linker created group section.
5916      See elfNN_ia64_object_p in elfxx-ia64.c.  */
5917
5918   if (need_group)
5919     {
5920       if (elf_sec_group (isec) == NULL
5921           || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
5922         {
5923           if (elf_section_flags (isec) & SHF_GROUP)
5924             elf_section_flags (osec) |= SHF_GROUP;
5925           elf_next_in_group (osec) = elf_next_in_group (isec);
5926           elf_group_name (osec) = elf_group_name (isec);
5927         }
5928     }
5929
5930   ihdr = &elf_section_data (isec)->this_hdr;
5931
5932   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
5933      don't use the output section of the linked-to section since it
5934      may be NULL at this point.  */
5935   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
5936     {
5937       ohdr = &elf_section_data (osec)->this_hdr;
5938       ohdr->sh_flags |= SHF_LINK_ORDER;
5939       elf_linked_to_section (osec) = elf_linked_to_section (isec);
5940     }
5941
5942   osec->use_rela_p = isec->use_rela_p;
5943
5944   return TRUE;
5945 }
5946
5947 /* Copy private section information.  This copies over the entsize
5948    field, and sometimes the info field.  */
5949
5950 bfd_boolean
5951 _bfd_elf_copy_private_section_data (bfd *ibfd,
5952                                     asection *isec,
5953                                     bfd *obfd,
5954                                     asection *osec)
5955 {
5956   Elf_Internal_Shdr *ihdr, *ohdr;
5957
5958   if (ibfd->xvec->flavour != bfd_target_elf_flavour
5959       || obfd->xvec->flavour != bfd_target_elf_flavour)
5960     return TRUE;
5961
5962   ihdr = &elf_section_data (isec)->this_hdr;
5963   ohdr = &elf_section_data (osec)->this_hdr;
5964
5965   ohdr->sh_entsize = ihdr->sh_entsize;
5966
5967   if (ihdr->sh_type == SHT_SYMTAB
5968       || ihdr->sh_type == SHT_DYNSYM
5969       || ihdr->sh_type == SHT_GNU_verneed
5970       || ihdr->sh_type == SHT_GNU_verdef)
5971     ohdr->sh_info = ihdr->sh_info;
5972
5973   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
5974                                              NULL);
5975 }
5976
5977 /* Copy private header information.  */
5978
5979 bfd_boolean
5980 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
5981 {
5982   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5983       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5984     return TRUE;
5985
5986   /* Copy over private BFD data if it has not already been copied.
5987      This must be done here, rather than in the copy_private_bfd_data
5988      entry point, because the latter is called after the section
5989      contents have been set, which means that the program headers have
5990      already been worked out.  */
5991   if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5992     {
5993       if (! copy_private_bfd_data (ibfd, obfd))
5994         return FALSE;
5995     }
5996
5997   return TRUE;
5998 }
5999
6000 /* Copy private symbol information.  If this symbol is in a section
6001    which we did not map into a BFD section, try to map the section
6002    index correctly.  We use special macro definitions for the mapped
6003    section indices; these definitions are interpreted by the
6004    swap_out_syms function.  */
6005
6006 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6007 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6008 #define MAP_STRTAB    (SHN_HIOS + 3)
6009 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
6010 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6011
6012 bfd_boolean
6013 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6014                                    asymbol *isymarg,
6015                                    bfd *obfd,
6016                                    asymbol *osymarg)
6017 {
6018   elf_symbol_type *isym, *osym;
6019
6020   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6021       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6022     return TRUE;
6023
6024   isym = elf_symbol_from (ibfd, isymarg);
6025   osym = elf_symbol_from (obfd, osymarg);
6026
6027   if (isym != NULL
6028       && osym != NULL
6029       && bfd_is_abs_section (isym->symbol.section))
6030     {
6031       unsigned int shndx;
6032
6033       shndx = isym->internal_elf_sym.st_shndx;
6034       if (shndx == elf_onesymtab (ibfd))
6035         shndx = MAP_ONESYMTAB;
6036       else if (shndx == elf_dynsymtab (ibfd))
6037         shndx = MAP_DYNSYMTAB;
6038       else if (shndx == elf_tdata (ibfd)->strtab_section)
6039         shndx = MAP_STRTAB;
6040       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6041         shndx = MAP_SHSTRTAB;
6042       else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6043         shndx = MAP_SYM_SHNDX;
6044       osym->internal_elf_sym.st_shndx = shndx;
6045     }
6046
6047   return TRUE;
6048 }
6049
6050 /* Swap out the symbols.  */
6051
6052 static bfd_boolean
6053 swap_out_syms (bfd *abfd,
6054                struct bfd_strtab_hash **sttp,
6055                int relocatable_p)
6056 {
6057   const struct elf_backend_data *bed;
6058   int symcount;
6059   asymbol **syms;
6060   struct bfd_strtab_hash *stt;
6061   Elf_Internal_Shdr *symtab_hdr;
6062   Elf_Internal_Shdr *symtab_shndx_hdr;
6063   Elf_Internal_Shdr *symstrtab_hdr;
6064   bfd_byte *outbound_syms;
6065   bfd_byte *outbound_shndx;
6066   int idx;
6067   bfd_size_type amt;
6068   bfd_boolean name_local_sections;
6069
6070   if (!elf_map_symbols (abfd))
6071     return FALSE;
6072
6073   /* Dump out the symtabs.  */
6074   stt = _bfd_elf_stringtab_init ();
6075   if (stt == NULL)
6076     return FALSE;
6077
6078   bed = get_elf_backend_data (abfd);
6079   symcount = bfd_get_symcount (abfd);
6080   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6081   symtab_hdr->sh_type = SHT_SYMTAB;
6082   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6083   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6084   symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6085   symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
6086
6087   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6088   symstrtab_hdr->sh_type = SHT_STRTAB;
6089
6090   outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
6091   if (outbound_syms == NULL)
6092     {
6093       _bfd_stringtab_free (stt);
6094       return FALSE;
6095     }
6096   symtab_hdr->contents = outbound_syms;
6097
6098   outbound_shndx = NULL;
6099   symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6100   if (symtab_shndx_hdr->sh_name != 0)
6101     {
6102       amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6103       outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
6104                                     sizeof (Elf_External_Sym_Shndx));
6105       if (outbound_shndx == NULL)
6106         {
6107           _bfd_stringtab_free (stt);
6108           return FALSE;
6109         }
6110
6111       symtab_shndx_hdr->contents = outbound_shndx;
6112       symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6113       symtab_shndx_hdr->sh_size = amt;
6114       symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6115       symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6116     }
6117
6118   /* Now generate the data (for "contents").  */
6119   {
6120     /* Fill in zeroth symbol and swap it out.  */
6121     Elf_Internal_Sym sym;
6122     sym.st_name = 0;
6123     sym.st_value = 0;
6124     sym.st_size = 0;
6125     sym.st_info = 0;
6126     sym.st_other = 0;
6127     sym.st_shndx = SHN_UNDEF;
6128     bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6129     outbound_syms += bed->s->sizeof_sym;
6130     if (outbound_shndx != NULL)
6131       outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6132   }
6133
6134   name_local_sections
6135     = (bed->elf_backend_name_local_section_symbols
6136        && bed->elf_backend_name_local_section_symbols (abfd));
6137
6138   syms = bfd_get_outsymbols (abfd);
6139   for (idx = 0; idx < symcount; idx++)
6140     {
6141       Elf_Internal_Sym sym;
6142       bfd_vma value = syms[idx]->value;
6143       elf_symbol_type *type_ptr;
6144       flagword flags = syms[idx]->flags;
6145       int type;
6146
6147       if (!name_local_sections
6148           && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6149         {
6150           /* Local section symbols have no name.  */
6151           sym.st_name = 0;
6152         }
6153       else
6154         {
6155           sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6156                                                             syms[idx]->name,
6157                                                             TRUE, FALSE);
6158           if (sym.st_name == (unsigned long) -1)
6159             {
6160               _bfd_stringtab_free (stt);
6161               return FALSE;
6162             }
6163         }
6164
6165       type_ptr = elf_symbol_from (abfd, syms[idx]);
6166
6167       if ((flags & BSF_SECTION_SYM) == 0
6168           && bfd_is_com_section (syms[idx]->section))
6169         {
6170           /* ELF common symbols put the alignment into the `value' field,
6171              and the size into the `size' field.  This is backwards from
6172              how BFD handles it, so reverse it here.  */
6173           sym.st_size = value;
6174           if (type_ptr == NULL
6175               || type_ptr->internal_elf_sym.st_value == 0)
6176             sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6177           else
6178             sym.st_value = type_ptr->internal_elf_sym.st_value;
6179           sym.st_shndx = _bfd_elf_section_from_bfd_section
6180             (abfd, syms[idx]->section);
6181         }
6182       else
6183         {
6184           asection *sec = syms[idx]->section;
6185           int shndx;
6186
6187           if (sec->output_section)
6188             {
6189               value += sec->output_offset;
6190               sec = sec->output_section;
6191             }
6192
6193           /* Don't add in the section vma for relocatable output.  */
6194           if (! relocatable_p)
6195             value += sec->vma;
6196           sym.st_value = value;
6197           sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6198
6199           if (bfd_is_abs_section (sec)
6200               && type_ptr != NULL
6201               && type_ptr->internal_elf_sym.st_shndx != 0)
6202             {
6203               /* This symbol is in a real ELF section which we did
6204                  not create as a BFD section.  Undo the mapping done
6205                  by copy_private_symbol_data.  */
6206               shndx = type_ptr->internal_elf_sym.st_shndx;
6207               switch (shndx)
6208                 {
6209                 case MAP_ONESYMTAB:
6210                   shndx = elf_onesymtab (abfd);
6211                   break;
6212                 case MAP_DYNSYMTAB:
6213                   shndx = elf_dynsymtab (abfd);
6214                   break;
6215                 case MAP_STRTAB:
6216                   shndx = elf_tdata (abfd)->strtab_section;
6217                   break;
6218                 case MAP_SHSTRTAB:
6219                   shndx = elf_tdata (abfd)->shstrtab_section;
6220                   break;
6221                 case MAP_SYM_SHNDX:
6222                   shndx = elf_tdata (abfd)->symtab_shndx_section;
6223                   break;
6224                 default:
6225                   break;
6226                 }
6227             }
6228           else
6229             {
6230               shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6231
6232               if (shndx == -1)
6233                 {
6234                   asection *sec2;
6235
6236                   /* Writing this would be a hell of a lot easier if
6237                      we had some decent documentation on bfd, and
6238                      knew what to expect of the library, and what to
6239                      demand of applications.  For example, it
6240                      appears that `objcopy' might not set the
6241                      section of a symbol to be a section that is
6242                      actually in the output file.  */
6243                   sec2 = bfd_get_section_by_name (abfd, sec->name);
6244                   if (sec2 == NULL)
6245                     {
6246                       _bfd_error_handler (_("\
6247 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6248                                           syms[idx]->name ? syms[idx]->name : "<Local sym>",
6249                                           sec->name);
6250                       bfd_set_error (bfd_error_invalid_operation);
6251                       _bfd_stringtab_free (stt);
6252                       return FALSE;
6253                     }
6254
6255                   shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6256                   BFD_ASSERT (shndx != -1);
6257                 }
6258             }
6259
6260           sym.st_shndx = shndx;
6261         }
6262
6263       if ((flags & BSF_THREAD_LOCAL) != 0)
6264         type = STT_TLS;
6265       else if ((flags & BSF_FUNCTION) != 0)
6266         type = STT_FUNC;
6267       else if ((flags & BSF_OBJECT) != 0)
6268         type = STT_OBJECT;
6269       else
6270         type = STT_NOTYPE;
6271
6272       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6273         type = STT_TLS;
6274
6275       /* Processor-specific types.  */
6276       if (type_ptr != NULL
6277           && bed->elf_backend_get_symbol_type)
6278         type = ((*bed->elf_backend_get_symbol_type)
6279                 (&type_ptr->internal_elf_sym, type));
6280
6281       if (flags & BSF_SECTION_SYM)
6282         {
6283           if (flags & BSF_GLOBAL)
6284             sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6285           else
6286             sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6287         }
6288       else if (bfd_is_com_section (syms[idx]->section))
6289         sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6290       else if (bfd_is_und_section (syms[idx]->section))
6291         sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6292                                     ? STB_WEAK
6293                                     : STB_GLOBAL),
6294                                    type);
6295       else if (flags & BSF_FILE)
6296         sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6297       else
6298         {
6299           int bind = STB_LOCAL;
6300
6301           if (flags & BSF_LOCAL)
6302             bind = STB_LOCAL;
6303           else if (flags & BSF_WEAK)
6304             bind = STB_WEAK;
6305           else if (flags & BSF_GLOBAL)
6306             bind = STB_GLOBAL;
6307
6308           sym.st_info = ELF_ST_INFO (bind, type);
6309         }
6310
6311       if (type_ptr != NULL)
6312         sym.st_other = type_ptr->internal_elf_sym.st_other;
6313       else
6314         sym.st_other = 0;
6315
6316       bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6317       outbound_syms += bed->s->sizeof_sym;
6318       if (outbound_shndx != NULL)
6319         outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6320     }
6321
6322   *sttp = stt;
6323   symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6324   symstrtab_hdr->sh_type = SHT_STRTAB;
6325
6326   symstrtab_hdr->sh_flags = 0;
6327   symstrtab_hdr->sh_addr = 0;
6328   symstrtab_hdr->sh_entsize = 0;
6329   symstrtab_hdr->sh_link = 0;
6330   symstrtab_hdr->sh_info = 0;
6331   symstrtab_hdr->sh_addralign = 1;
6332
6333   return TRUE;
6334 }
6335
6336 /* Return the number of bytes required to hold the symtab vector.
6337
6338    Note that we base it on the count plus 1, since we will null terminate
6339    the vector allocated based on this size.  However, the ELF symbol table
6340    always has a dummy entry as symbol #0, so it ends up even.  */
6341
6342 long
6343 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6344 {
6345   long symcount;
6346   long symtab_size;
6347   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6348
6349   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6350   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6351   if (symcount > 0)
6352     symtab_size -= sizeof (asymbol *);
6353
6354   return symtab_size;
6355 }
6356
6357 long
6358 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6359 {
6360   long symcount;
6361   long symtab_size;
6362   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6363
6364   if (elf_dynsymtab (abfd) == 0)
6365     {
6366       bfd_set_error (bfd_error_invalid_operation);
6367       return -1;
6368     }
6369
6370   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6371   symtab_size = (symcount + 1) * (sizeof (asymbol *));
6372   if (symcount > 0)
6373     symtab_size -= sizeof (asymbol *);
6374
6375   return symtab_size;
6376 }
6377
6378 long
6379 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6380                                 sec_ptr asect)
6381 {
6382   return (asect->reloc_count + 1) * sizeof (arelent *);
6383 }
6384
6385 /* Canonicalize the relocs.  */
6386
6387 long
6388 _bfd_elf_canonicalize_reloc (bfd *abfd,
6389                              sec_ptr section,
6390                              arelent **relptr,
6391                              asymbol **symbols)
6392 {
6393   arelent *tblptr;
6394   unsigned int i;
6395   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6396
6397   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6398     return -1;
6399
6400   tblptr = section->relocation;
6401   for (i = 0; i < section->reloc_count; i++)
6402     *relptr++ = tblptr++;
6403
6404   *relptr = NULL;
6405
6406   return section->reloc_count;
6407 }
6408
6409 long
6410 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6411 {
6412   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6413   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6414
6415   if (symcount >= 0)
6416     bfd_get_symcount (abfd) = symcount;
6417   return symcount;
6418 }
6419
6420 long
6421 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6422                                       asymbol **allocation)
6423 {
6424   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6425   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6426
6427   if (symcount >= 0)
6428     bfd_get_dynamic_symcount (abfd) = symcount;
6429   return symcount;
6430 }
6431
6432 /* Return the size required for the dynamic reloc entries.  Any loadable
6433    section that was actually installed in the BFD, and has type SHT_REL
6434    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6435    dynamic reloc section.  */
6436
6437 long
6438 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6439 {
6440   long ret;
6441   asection *s;
6442
6443   if (elf_dynsymtab (abfd) == 0)
6444     {
6445       bfd_set_error (bfd_error_invalid_operation);
6446       return -1;
6447     }
6448
6449   ret = sizeof (arelent *);
6450   for (s = abfd->sections; s != NULL; s = s->next)
6451     if ((s->flags & SEC_LOAD) != 0
6452         && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6453         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6454             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6455       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6456               * sizeof (arelent *));
6457
6458   return ret;
6459 }
6460
6461 /* Canonicalize the dynamic relocation entries.  Note that we return the
6462    dynamic relocations as a single block, although they are actually
6463    associated with particular sections; the interface, which was
6464    designed for SunOS style shared libraries, expects that there is only
6465    one set of dynamic relocs.  Any loadable section that was actually
6466    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6467    dynamic symbol table, is considered to be a dynamic reloc section.  */
6468
6469 long
6470 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6471                                      arelent **storage,
6472                                      asymbol **syms)
6473 {
6474   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6475   asection *s;
6476   long ret;
6477
6478   if (elf_dynsymtab (abfd) == 0)
6479     {
6480       bfd_set_error (bfd_error_invalid_operation);
6481       return -1;
6482     }
6483
6484   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6485   ret = 0;
6486   for (s = abfd->sections; s != NULL; s = s->next)
6487     {
6488       if ((s->flags & SEC_LOAD) != 0
6489           && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6490           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6491               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6492         {
6493           arelent *p;
6494           long count, i;
6495
6496           if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6497             return -1;
6498           count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6499           p = s->relocation;
6500           for (i = 0; i < count; i++)
6501             *storage++ = p++;
6502           ret += count;
6503         }
6504     }
6505
6506   *storage = NULL;
6507
6508   return ret;
6509 }
6510 \f
6511 /* Read in the version information.  */
6512
6513 bfd_boolean
6514 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6515 {
6516   bfd_byte *contents = NULL;
6517   unsigned int freeidx = 0;
6518
6519   if (elf_dynverref (abfd) != 0)
6520     {
6521       Elf_Internal_Shdr *hdr;
6522       Elf_External_Verneed *everneed;
6523       Elf_Internal_Verneed *iverneed;
6524       unsigned int i;
6525       bfd_byte *contents_end;
6526
6527       hdr = &elf_tdata (abfd)->dynverref_hdr;
6528
6529       elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6530                                               sizeof (Elf_Internal_Verneed));
6531       if (elf_tdata (abfd)->verref == NULL)
6532         goto error_return;
6533
6534       elf_tdata (abfd)->cverrefs = hdr->sh_info;
6535
6536       contents = bfd_malloc (hdr->sh_size);
6537       if (contents == NULL)
6538         {
6539 error_return_verref:
6540           elf_tdata (abfd)->verref = NULL;
6541           elf_tdata (abfd)->cverrefs = 0;
6542           goto error_return;
6543         }
6544       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6545           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6546         goto error_return_verref;
6547
6548       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6549         goto error_return_verref;
6550
6551       BFD_ASSERT (sizeof (Elf_External_Verneed)
6552                   == sizeof (Elf_External_Vernaux));
6553       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6554       everneed = (Elf_External_Verneed *) contents;
6555       iverneed = elf_tdata (abfd)->verref;
6556       for (i = 0; i < hdr->sh_info; i++, iverneed++)
6557         {
6558           Elf_External_Vernaux *evernaux;
6559           Elf_Internal_Vernaux *ivernaux;
6560           unsigned int j;
6561
6562           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6563
6564           iverneed->vn_bfd = abfd;
6565
6566           iverneed->vn_filename =
6567             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6568                                              iverneed->vn_file);
6569           if (iverneed->vn_filename == NULL)
6570             goto error_return_verref;
6571
6572           if (iverneed->vn_cnt == 0)
6573             iverneed->vn_auxptr = NULL;
6574           else
6575             {
6576               iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6577                                                 sizeof (Elf_Internal_Vernaux));
6578               if (iverneed->vn_auxptr == NULL)
6579                 goto error_return_verref;
6580             }
6581
6582           if (iverneed->vn_aux
6583               > (size_t) (contents_end - (bfd_byte *) everneed))
6584             goto error_return_verref;
6585
6586           evernaux = ((Elf_External_Vernaux *)
6587                       ((bfd_byte *) everneed + iverneed->vn_aux));
6588           ivernaux = iverneed->vn_auxptr;
6589           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6590             {
6591               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6592
6593               ivernaux->vna_nodename =
6594                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6595                                                  ivernaux->vna_name);
6596               if (ivernaux->vna_nodename == NULL)
6597                 goto error_return_verref;
6598
6599               if (j + 1 < iverneed->vn_cnt)
6600                 ivernaux->vna_nextptr = ivernaux + 1;
6601               else
6602                 ivernaux->vna_nextptr = NULL;
6603
6604               if (ivernaux->vna_next
6605                   > (size_t) (contents_end - (bfd_byte *) evernaux))
6606                 goto error_return_verref;
6607
6608               evernaux = ((Elf_External_Vernaux *)
6609                           ((bfd_byte *) evernaux + ivernaux->vna_next));
6610
6611               if (ivernaux->vna_other > freeidx)
6612                 freeidx = ivernaux->vna_other;
6613             }
6614
6615           if (i + 1 < hdr->sh_info)
6616             iverneed->vn_nextref = iverneed + 1;
6617           else
6618             iverneed->vn_nextref = NULL;
6619
6620           if (iverneed->vn_next
6621               > (size_t) (contents_end - (bfd_byte *) everneed))
6622             goto error_return_verref;
6623
6624           everneed = ((Elf_External_Verneed *)
6625                       ((bfd_byte *) everneed + iverneed->vn_next));
6626         }
6627
6628       free (contents);
6629       contents = NULL;
6630     }
6631
6632   if (elf_dynverdef (abfd) != 0)
6633     {
6634       Elf_Internal_Shdr *hdr;
6635       Elf_External_Verdef *everdef;
6636       Elf_Internal_Verdef *iverdef;
6637       Elf_Internal_Verdef *iverdefarr;
6638       Elf_Internal_Verdef iverdefmem;
6639       unsigned int i;
6640       unsigned int maxidx;
6641       bfd_byte *contents_end_def, *contents_end_aux;
6642
6643       hdr = &elf_tdata (abfd)->dynverdef_hdr;
6644
6645       contents = bfd_malloc (hdr->sh_size);
6646       if (contents == NULL)
6647         goto error_return;
6648       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6649           || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6650         goto error_return;
6651
6652       if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6653         goto error_return;
6654
6655       BFD_ASSERT (sizeof (Elf_External_Verdef)
6656                   >= sizeof (Elf_External_Verdaux));
6657       contents_end_def = contents + hdr->sh_size
6658                          - sizeof (Elf_External_Verdef);
6659       contents_end_aux = contents + hdr->sh_size
6660                          - sizeof (Elf_External_Verdaux);
6661
6662       /* We know the number of entries in the section but not the maximum
6663          index.  Therefore we have to run through all entries and find
6664          the maximum.  */
6665       everdef = (Elf_External_Verdef *) contents;
6666       maxidx = 0;
6667       for (i = 0; i < hdr->sh_info; ++i)
6668         {
6669           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6670
6671           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6672             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6673
6674           if (iverdefmem.vd_next
6675               > (size_t) (contents_end_def - (bfd_byte *) everdef))
6676             goto error_return;
6677
6678           everdef = ((Elf_External_Verdef *)
6679                      ((bfd_byte *) everdef + iverdefmem.vd_next));
6680         }
6681
6682       if (default_imported_symver)
6683         {
6684           if (freeidx > maxidx)
6685             maxidx = ++freeidx;
6686           else
6687             freeidx = ++maxidx;
6688         }
6689       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6690                                               sizeof (Elf_Internal_Verdef));
6691       if (elf_tdata (abfd)->verdef == NULL)
6692         goto error_return;
6693
6694       elf_tdata (abfd)->cverdefs = maxidx;
6695
6696       everdef = (Elf_External_Verdef *) contents;
6697       iverdefarr = elf_tdata (abfd)->verdef;
6698       for (i = 0; i < hdr->sh_info; i++)
6699         {
6700           Elf_External_Verdaux *everdaux;
6701           Elf_Internal_Verdaux *iverdaux;
6702           unsigned int j;
6703
6704           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6705
6706           if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6707             {
6708 error_return_verdef:
6709               elf_tdata (abfd)->verdef = NULL;
6710               elf_tdata (abfd)->cverdefs = 0;
6711               goto error_return;
6712             }
6713
6714           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6715           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6716
6717           iverdef->vd_bfd = abfd;
6718
6719           if (iverdef->vd_cnt == 0)
6720             iverdef->vd_auxptr = NULL;
6721           else
6722             {
6723               iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6724                                                sizeof (Elf_Internal_Verdaux));
6725               if (iverdef->vd_auxptr == NULL)
6726                 goto error_return_verdef;
6727             }
6728
6729           if (iverdef->vd_aux
6730               > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6731             goto error_return_verdef;
6732
6733           everdaux = ((Elf_External_Verdaux *)
6734                       ((bfd_byte *) everdef + iverdef->vd_aux));
6735           iverdaux = iverdef->vd_auxptr;
6736           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6737             {
6738               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6739
6740               iverdaux->vda_nodename =
6741                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6742                                                  iverdaux->vda_name);
6743               if (iverdaux->vda_nodename == NULL)
6744                 goto error_return_verdef;
6745
6746               if (j + 1 < iverdef->vd_cnt)
6747                 iverdaux->vda_nextptr = iverdaux + 1;
6748               else
6749                 iverdaux->vda_nextptr = NULL;
6750
6751               if (iverdaux->vda_next
6752                   > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6753                 goto error_return_verdef;
6754
6755               everdaux = ((Elf_External_Verdaux *)
6756                           ((bfd_byte *) everdaux + iverdaux->vda_next));
6757             }
6758
6759           if (iverdef->vd_cnt)
6760             iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6761
6762           if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
6763             iverdef->vd_nextdef = iverdef + 1;
6764           else
6765             iverdef->vd_nextdef = NULL;
6766
6767           everdef = ((Elf_External_Verdef *)
6768                      ((bfd_byte *) everdef + iverdef->vd_next));
6769         }
6770
6771       free (contents);
6772       contents = NULL;
6773     }
6774   else if (default_imported_symver)
6775     {
6776       if (freeidx < 3)
6777         freeidx = 3;
6778       else
6779         freeidx++;
6780
6781       elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6782                                               sizeof (Elf_Internal_Verdef));
6783       if (elf_tdata (abfd)->verdef == NULL)
6784         goto error_return;
6785
6786       elf_tdata (abfd)->cverdefs = freeidx;
6787     }
6788
6789   /* Create a default version based on the soname.  */
6790   if (default_imported_symver)
6791     {
6792       Elf_Internal_Verdef *iverdef;
6793       Elf_Internal_Verdaux *iverdaux;
6794
6795       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6796
6797       iverdef->vd_version = VER_DEF_CURRENT;
6798       iverdef->vd_flags = 0;
6799       iverdef->vd_ndx = freeidx;
6800       iverdef->vd_cnt = 1;
6801
6802       iverdef->vd_bfd = abfd;
6803
6804       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6805       if (iverdef->vd_nodename == NULL)
6806         goto error_return_verdef;
6807       iverdef->vd_nextdef = NULL;
6808       iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6809       if (iverdef->vd_auxptr == NULL)
6810         goto error_return_verdef;
6811
6812       iverdaux = iverdef->vd_auxptr;
6813       iverdaux->vda_nodename = iverdef->vd_nodename;
6814       iverdaux->vda_nextptr = NULL;
6815     }
6816
6817   return TRUE;
6818
6819  error_return:
6820   if (contents != NULL)
6821     free (contents);
6822   return FALSE;
6823 }
6824 \f
6825 asymbol *
6826 _bfd_elf_make_empty_symbol (bfd *abfd)
6827 {
6828   elf_symbol_type *newsym;
6829   bfd_size_type amt = sizeof (elf_symbol_type);
6830
6831   newsym = bfd_zalloc (abfd, amt);
6832   if (!newsym)
6833     return NULL;
6834   else
6835     {
6836       newsym->symbol.the_bfd = abfd;
6837       return &newsym->symbol;
6838     }
6839 }
6840
6841 void
6842 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6843                           asymbol *symbol,
6844                           symbol_info *ret)
6845 {
6846   bfd_symbol_info (symbol, ret);
6847 }
6848
6849 /* Return whether a symbol name implies a local symbol.  Most targets
6850    use this function for the is_local_label_name entry point, but some
6851    override it.  */
6852
6853 bfd_boolean
6854 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6855                               const char *name)
6856 {
6857   /* Normal local symbols start with ``.L''.  */
6858   if (name[0] == '.' && name[1] == 'L')
6859     return TRUE;
6860
6861   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6862      DWARF debugging symbols starting with ``..''.  */
6863   if (name[0] == '.' && name[1] == '.')
6864     return TRUE;
6865
6866   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6867      emitting DWARF debugging output.  I suspect this is actually a
6868      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6869      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6870      underscore to be emitted on some ELF targets).  For ease of use,
6871      we treat such symbols as local.  */
6872   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
6873     return TRUE;
6874
6875   return FALSE;
6876 }
6877
6878 alent *
6879 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6880                      asymbol *symbol ATTRIBUTE_UNUSED)
6881 {
6882   abort ();
6883   return NULL;
6884 }
6885
6886 bfd_boolean
6887 _bfd_elf_set_arch_mach (bfd *abfd,
6888                         enum bfd_architecture arch,
6889                         unsigned long machine)
6890 {
6891   /* If this isn't the right architecture for this backend, and this
6892      isn't the generic backend, fail.  */
6893   if (arch != get_elf_backend_data (abfd)->arch
6894       && arch != bfd_arch_unknown
6895       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
6896     return FALSE;
6897
6898   return bfd_default_set_arch_mach (abfd, arch, machine);
6899 }
6900
6901 /* Find the function to a particular section and offset,
6902    for error reporting.  */
6903
6904 static bfd_boolean
6905 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6906                    asection *section,
6907                    asymbol **symbols,
6908                    bfd_vma offset,
6909                    const char **filename_ptr,
6910                    const char **functionname_ptr)
6911 {
6912   const char *filename;
6913   asymbol *func, *file;
6914   bfd_vma low_func;
6915   asymbol **p;
6916   /* ??? Given multiple file symbols, it is impossible to reliably
6917      choose the right file name for global symbols.  File symbols are
6918      local symbols, and thus all file symbols must sort before any
6919      global symbols.  The ELF spec may be interpreted to say that a
6920      file symbol must sort before other local symbols, but currently
6921      ld -r doesn't do this.  So, for ld -r output, it is possible to
6922      make a better choice of file name for local symbols by ignoring
6923      file symbols appearing after a given local symbol.  */
6924   enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
6925
6926   filename = NULL;
6927   func = NULL;
6928   file = NULL;
6929   low_func = 0;
6930   state = nothing_seen;
6931
6932   for (p = symbols; *p != NULL; p++)
6933     {
6934       elf_symbol_type *q;
6935
6936       q = (elf_symbol_type *) *p;
6937
6938       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6939         {
6940         default:
6941           break;
6942         case STT_FILE:
6943           file = &q->symbol;
6944           if (state == symbol_seen)
6945             state = file_after_symbol_seen;
6946           continue;
6947         case STT_NOTYPE:
6948         case STT_FUNC:
6949           if (bfd_get_section (&q->symbol) == section
6950               && q->symbol.value >= low_func
6951               && q->symbol.value <= offset)
6952             {
6953               func = (asymbol *) q;
6954               low_func = q->symbol.value;
6955               filename = NULL;
6956               if (file != NULL
6957                   && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
6958                       || state != file_after_symbol_seen))
6959                 filename = bfd_asymbol_name (file);
6960             }
6961           break;
6962         }
6963       if (state == nothing_seen)
6964         state = symbol_seen;
6965     }
6966
6967   if (func == NULL)
6968     return FALSE;
6969
6970   if (filename_ptr)
6971     *filename_ptr = filename;
6972   if (functionname_ptr)
6973     *functionname_ptr = bfd_asymbol_name (func);
6974
6975   return TRUE;
6976 }
6977
6978 /* Find the nearest line to a particular section and offset,
6979    for error reporting.  */
6980
6981 bfd_boolean
6982 _bfd_elf_find_nearest_line (bfd *abfd,
6983                             asection *section,
6984                             asymbol **symbols,
6985                             bfd_vma offset,
6986                             const char **filename_ptr,
6987                             const char **functionname_ptr,
6988                             unsigned int *line_ptr)
6989 {
6990   bfd_boolean found;
6991
6992   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6993                                      filename_ptr, functionname_ptr,
6994                                      line_ptr))
6995     {
6996       if (!*functionname_ptr)
6997         elf_find_function (abfd, section, symbols, offset,
6998                            *filename_ptr ? NULL : filename_ptr,
6999                            functionname_ptr);
7000
7001       return TRUE;
7002     }
7003
7004   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7005                                      filename_ptr, functionname_ptr,
7006                                      line_ptr, 0,
7007                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7008     {
7009       if (!*functionname_ptr)
7010         elf_find_function (abfd, section, symbols, offset,
7011                            *filename_ptr ? NULL : filename_ptr,
7012                            functionname_ptr);
7013
7014       return TRUE;
7015     }
7016
7017   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7018                                              &found, filename_ptr,
7019                                              functionname_ptr, line_ptr,
7020                                              &elf_tdata (abfd)->line_info))
7021     return FALSE;
7022   if (found && (*functionname_ptr || *line_ptr))
7023     return TRUE;
7024
7025   if (symbols == NULL)
7026     return FALSE;
7027
7028   if (! elf_find_function (abfd, section, symbols, offset,
7029                            filename_ptr, functionname_ptr))
7030     return FALSE;
7031
7032   *line_ptr = 0;
7033   return TRUE;
7034 }
7035
7036 /* Find the line for a symbol.  */
7037
7038 bfd_boolean
7039 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7040                     const char **filename_ptr, unsigned int *line_ptr)
7041 {
7042   return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7043                                 filename_ptr, line_ptr, 0,
7044                                 &elf_tdata (abfd)->dwarf2_find_line_info);
7045 }
7046
7047 /* After a call to bfd_find_nearest_line, successive calls to
7048    bfd_find_inliner_info can be used to get source information about
7049    each level of function inlining that terminated at the address
7050    passed to bfd_find_nearest_line.  Currently this is only supported
7051    for DWARF2 with appropriate DWARF3 extensions. */
7052
7053 bfd_boolean
7054 _bfd_elf_find_inliner_info (bfd *abfd,
7055                             const char **filename_ptr,
7056                             const char **functionname_ptr,
7057                             unsigned int *line_ptr)
7058 {
7059   bfd_boolean found;
7060   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7061                                          functionname_ptr, line_ptr,
7062                                          & elf_tdata (abfd)->dwarf2_find_line_info);
7063   return found;
7064 }
7065
7066 int
7067 _bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
7068 {
7069   int ret;
7070
7071   ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
7072   if (! reloc)
7073     ret += get_program_header_size (abfd);
7074   return ret;
7075 }
7076
7077 bfd_boolean
7078 _bfd_elf_set_section_contents (bfd *abfd,
7079                                sec_ptr section,
7080                                const void *location,
7081                                file_ptr offset,
7082                                bfd_size_type count)
7083 {
7084   Elf_Internal_Shdr *hdr;
7085   bfd_signed_vma pos;
7086
7087   if (! abfd->output_has_begun
7088       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7089     return FALSE;
7090
7091   hdr = &elf_section_data (section)->this_hdr;
7092   pos = hdr->sh_offset + offset;
7093   if (bfd_seek (abfd, pos, SEEK_SET) != 0
7094       || bfd_bwrite (location, count, abfd) != count)
7095     return FALSE;
7096
7097   return TRUE;
7098 }
7099
7100 void
7101 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7102                            arelent *cache_ptr ATTRIBUTE_UNUSED,
7103                            Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7104 {
7105   abort ();
7106 }
7107
7108 /* Try to convert a non-ELF reloc into an ELF one.  */
7109
7110 bfd_boolean
7111 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7112 {
7113   /* Check whether we really have an ELF howto.  */
7114
7115   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7116     {
7117       bfd_reloc_code_real_type code;
7118       reloc_howto_type *howto;
7119
7120       /* Alien reloc: Try to determine its type to replace it with an
7121          equivalent ELF reloc.  */
7122
7123       if (areloc->howto->pc_relative)
7124         {
7125           switch (areloc->howto->bitsize)
7126             {
7127             case 8:
7128               code = BFD_RELOC_8_PCREL;
7129               break;
7130             case 12:
7131               code = BFD_RELOC_12_PCREL;
7132               break;
7133             case 16:
7134               code = BFD_RELOC_16_PCREL;
7135               break;
7136             case 24:
7137               code = BFD_RELOC_24_PCREL;
7138               break;
7139             case 32:
7140               code = BFD_RELOC_32_PCREL;
7141               break;
7142             case 64:
7143               code = BFD_RELOC_64_PCREL;
7144               break;
7145             default:
7146               goto fail;
7147             }
7148
7149           howto = bfd_reloc_type_lookup (abfd, code);
7150
7151           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7152             {
7153               if (howto->pcrel_offset)
7154                 areloc->addend += areloc->address;
7155               else
7156                 areloc->addend -= areloc->address; /* addend is unsigned!! */
7157             }
7158         }
7159       else
7160         {
7161           switch (areloc->howto->bitsize)
7162             {
7163             case 8:
7164               code = BFD_RELOC_8;
7165               break;
7166             case 14:
7167               code = BFD_RELOC_14;
7168               break;
7169             case 16:
7170               code = BFD_RELOC_16;
7171               break;
7172             case 26:
7173               code = BFD_RELOC_26;
7174               break;
7175             case 32:
7176               code = BFD_RELOC_32;
7177               break;
7178             case 64:
7179               code = BFD_RELOC_64;
7180               break;
7181             default:
7182               goto fail;
7183             }
7184
7185           howto = bfd_reloc_type_lookup (abfd, code);
7186         }
7187
7188       if (howto)
7189         areloc->howto = howto;
7190       else
7191         goto fail;
7192     }
7193
7194   return TRUE;
7195
7196  fail:
7197   (*_bfd_error_handler)
7198     (_("%B: unsupported relocation type %s"),
7199      abfd, areloc->howto->name);
7200   bfd_set_error (bfd_error_bad_value);
7201   return FALSE;
7202 }
7203
7204 bfd_boolean
7205 _bfd_elf_close_and_cleanup (bfd *abfd)
7206 {
7207   if (bfd_get_format (abfd) == bfd_object)
7208     {
7209       if (elf_shstrtab (abfd) != NULL)
7210         _bfd_elf_strtab_free (elf_shstrtab (abfd));
7211       _bfd_dwarf2_cleanup_debug_info (abfd);
7212     }
7213
7214   return _bfd_generic_close_and_cleanup (abfd);
7215 }
7216
7217 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7218    in the relocation's offset.  Thus we cannot allow any sort of sanity
7219    range-checking to interfere.  There is nothing else to do in processing
7220    this reloc.  */
7221
7222 bfd_reloc_status_type
7223 _bfd_elf_rel_vtable_reloc_fn
7224   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7225    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7226    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7227    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7228 {
7229   return bfd_reloc_ok;
7230 }
7231 \f
7232 /* Elf core file support.  Much of this only works on native
7233    toolchains, since we rely on knowing the
7234    machine-dependent procfs structure in order to pick
7235    out details about the corefile.  */
7236
7237 #ifdef HAVE_SYS_PROCFS_H
7238 # include <sys/procfs.h>
7239 #endif
7240
7241 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
7242
7243 static int
7244 elfcore_make_pid (bfd *abfd)
7245 {
7246   return ((elf_tdata (abfd)->core_lwpid << 16)
7247           + (elf_tdata (abfd)->core_pid));
7248 }
7249
7250 /* If there isn't a section called NAME, make one, using
7251    data from SECT.  Note, this function will generate a
7252    reference to NAME, so you shouldn't deallocate or
7253    overwrite it.  */
7254
7255 static bfd_boolean
7256 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7257 {
7258   asection *sect2;
7259
7260   if (bfd_get_section_by_name (abfd, name) != NULL)
7261     return TRUE;
7262
7263   sect2 = bfd_make_section (abfd, name);
7264   if (sect2 == NULL)
7265     return FALSE;
7266
7267   sect2->size = sect->size;
7268   sect2->filepos = sect->filepos;
7269   sect2->flags = sect->flags;
7270   sect2->alignment_power = sect->alignment_power;
7271   return TRUE;
7272 }
7273
7274 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
7275    actually creates up to two pseudosections:
7276    - For the single-threaded case, a section named NAME, unless
7277      such a section already exists.
7278    - For the multi-threaded case, a section named "NAME/PID", where
7279      PID is elfcore_make_pid (abfd).
7280    Both pseudosections have identical contents. */
7281 bfd_boolean
7282 _bfd_elfcore_make_pseudosection (bfd *abfd,
7283                                  char *name,
7284                                  size_t size,
7285                                  ufile_ptr filepos)
7286 {
7287   char buf[100];
7288   char *threaded_name;
7289   size_t len;
7290   asection *sect;
7291
7292   /* Build the section name.  */
7293
7294   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7295   len = strlen (buf) + 1;
7296   threaded_name = bfd_alloc (abfd, len);
7297   if (threaded_name == NULL)
7298     return FALSE;
7299   memcpy (threaded_name, buf, len);
7300
7301   sect = bfd_make_section_anyway (abfd, threaded_name);
7302   if (sect == NULL)
7303     return FALSE;
7304   sect->size = size;
7305   sect->filepos = filepos;
7306   sect->flags = SEC_HAS_CONTENTS;
7307   sect->alignment_power = 2;
7308
7309   return elfcore_maybe_make_sect (abfd, name, sect);
7310 }
7311
7312 /* prstatus_t exists on:
7313      solaris 2.5+
7314      linux 2.[01] + glibc
7315      unixware 4.2
7316 */
7317
7318 #if defined (HAVE_PRSTATUS_T)
7319
7320 static bfd_boolean
7321 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7322 {
7323   size_t size;
7324   int offset;
7325
7326   if (note->descsz == sizeof (prstatus_t))
7327     {
7328       prstatus_t prstat;
7329
7330       size = sizeof (prstat.pr_reg);
7331       offset   = offsetof (prstatus_t, pr_reg);
7332       memcpy (&prstat, note->descdata, sizeof (prstat));
7333
7334       /* Do not overwrite the core signal if it
7335          has already been set by another thread.  */
7336       if (elf_tdata (abfd)->core_signal == 0)
7337         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7338       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7339
7340       /* pr_who exists on:
7341          solaris 2.5+
7342          unixware 4.2
7343          pr_who doesn't exist on:
7344          linux 2.[01]
7345          */
7346 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7347       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7348 #endif
7349     }
7350 #if defined (HAVE_PRSTATUS32_T)
7351   else if (note->descsz == sizeof (prstatus32_t))
7352     {
7353       /* 64-bit host, 32-bit corefile */
7354       prstatus32_t prstat;
7355
7356       size = sizeof (prstat.pr_reg);
7357       offset   = offsetof (prstatus32_t, pr_reg);
7358       memcpy (&prstat, note->descdata, sizeof (prstat));
7359
7360       /* Do not overwrite the core signal if it
7361          has already been set by another thread.  */
7362       if (elf_tdata (abfd)->core_signal == 0)
7363         elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7364       elf_tdata (abfd)->core_pid = prstat.pr_pid;
7365
7366       /* pr_who exists on:
7367          solaris 2.5+
7368          unixware 4.2
7369          pr_who doesn't exist on:
7370          linux 2.[01]
7371          */
7372 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7373       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7374 #endif
7375     }
7376 #endif /* HAVE_PRSTATUS32_T */
7377   else
7378     {
7379       /* Fail - we don't know how to handle any other
7380          note size (ie. data object type).  */
7381       return TRUE;
7382     }
7383
7384   /* Make a ".reg/999" section and a ".reg" section.  */
7385   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7386                                           size, note->descpos + offset);
7387 }
7388 #endif /* defined (HAVE_PRSTATUS_T) */
7389
7390 /* Create a pseudosection containing the exact contents of NOTE.  */
7391 static bfd_boolean
7392 elfcore_make_note_pseudosection (bfd *abfd,
7393                                  char *name,
7394                                  Elf_Internal_Note *note)
7395 {
7396   return _bfd_elfcore_make_pseudosection (abfd, name,
7397                                           note->descsz, note->descpos);
7398 }
7399
7400 /* There isn't a consistent prfpregset_t across platforms,
7401    but it doesn't matter, because we don't have to pick this
7402    data structure apart.  */
7403
7404 static bfd_boolean
7405 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7406 {
7407   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7408 }
7409
7410 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7411    type of 5 (NT_PRXFPREG).  Just include the whole note's contents
7412    literally.  */
7413
7414 static bfd_boolean
7415 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7416 {
7417   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7418 }
7419
7420 #if defined (HAVE_PRPSINFO_T)
7421 typedef prpsinfo_t   elfcore_psinfo_t;
7422 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
7423 typedef prpsinfo32_t elfcore_psinfo32_t;
7424 #endif
7425 #endif
7426
7427 #if defined (HAVE_PSINFO_T)
7428 typedef psinfo_t   elfcore_psinfo_t;
7429 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
7430 typedef psinfo32_t elfcore_psinfo32_t;
7431 #endif
7432 #endif
7433
7434 /* return a malloc'ed copy of a string at START which is at
7435    most MAX bytes long, possibly without a terminating '\0'.
7436    the copy will always have a terminating '\0'.  */
7437
7438 char *
7439 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7440 {
7441   char *dups;
7442   char *end = memchr (start, '\0', max);
7443   size_t len;
7444
7445   if (end == NULL)
7446     len = max;
7447   else
7448     len = end - start;
7449
7450   dups = bfd_alloc (abfd, len + 1);
7451   if (dups == NULL)
7452     return NULL;
7453
7454   memcpy (dups, start, len);
7455   dups[len] = '\0';
7456
7457   return dups;
7458 }
7459
7460 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7461 static bfd_boolean
7462 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7463 {
7464   if (note->descsz == sizeof (elfcore_psinfo_t))
7465     {
7466       elfcore_psinfo_t psinfo;
7467
7468       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7469
7470       elf_tdata (abfd)->core_program
7471         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7472                                 sizeof (psinfo.pr_fname));
7473
7474       elf_tdata (abfd)->core_command
7475         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7476                                 sizeof (psinfo.pr_psargs));
7477     }
7478 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7479   else if (note->descsz == sizeof (elfcore_psinfo32_t))
7480     {
7481       /* 64-bit host, 32-bit corefile */
7482       elfcore_psinfo32_t psinfo;
7483
7484       memcpy (&psinfo, note->descdata, sizeof (psinfo));
7485
7486       elf_tdata (abfd)->core_program
7487         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7488                                 sizeof (psinfo.pr_fname));
7489
7490       elf_tdata (abfd)->core_command
7491         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7492                                 sizeof (psinfo.pr_psargs));
7493     }
7494 #endif
7495
7496   else
7497     {
7498       /* Fail - we don't know how to handle any other
7499          note size (ie. data object type).  */
7500       return TRUE;
7501     }
7502
7503   /* Note that for some reason, a spurious space is tacked
7504      onto the end of the args in some (at least one anyway)
7505      implementations, so strip it off if it exists.  */
7506
7507   {
7508     char *command = elf_tdata (abfd)->core_command;
7509     int n = strlen (command);
7510
7511     if (0 < n && command[n - 1] == ' ')
7512       command[n - 1] = '\0';
7513   }
7514
7515   return TRUE;
7516 }
7517 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7518
7519 #if defined (HAVE_PSTATUS_T)
7520 static bfd_boolean
7521 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7522 {
7523   if (note->descsz == sizeof (pstatus_t)
7524 #if defined (HAVE_PXSTATUS_T)
7525       || note->descsz == sizeof (pxstatus_t)
7526 #endif
7527       )
7528     {
7529       pstatus_t pstat;
7530
7531       memcpy (&pstat, note->descdata, sizeof (pstat));
7532
7533       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7534     }
7535 #if defined (HAVE_PSTATUS32_T)
7536   else if (note->descsz == sizeof (pstatus32_t))
7537     {
7538       /* 64-bit host, 32-bit corefile */
7539       pstatus32_t pstat;
7540
7541       memcpy (&pstat, note->descdata, sizeof (pstat));
7542
7543       elf_tdata (abfd)->core_pid = pstat.pr_pid;
7544     }
7545 #endif
7546   /* Could grab some more details from the "representative"
7547      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7548      NT_LWPSTATUS note, presumably.  */
7549
7550   return TRUE;
7551 }
7552 #endif /* defined (HAVE_PSTATUS_T) */
7553
7554 #if defined (HAVE_LWPSTATUS_T)
7555 static bfd_boolean
7556 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7557 {
7558   lwpstatus_t lwpstat;
7559   char buf[100];
7560   char *name;
7561   size_t len;
7562   asection *sect;
7563
7564   if (note->descsz != sizeof (lwpstat)
7565 #if defined (HAVE_LWPXSTATUS_T)
7566       && note->descsz != sizeof (lwpxstatus_t)
7567 #endif
7568       )
7569     return TRUE;
7570
7571   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7572
7573   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7574   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7575
7576   /* Make a ".reg/999" section.  */
7577
7578   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7579   len = strlen (buf) + 1;
7580   name = bfd_alloc (abfd, len);
7581   if (name == NULL)
7582     return FALSE;
7583   memcpy (name, buf, len);
7584
7585   sect = bfd_make_section_anyway (abfd, name);
7586   if (sect == NULL)
7587     return FALSE;
7588
7589 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7590   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7591   sect->filepos = note->descpos
7592     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7593 #endif
7594
7595 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7596   sect->size = sizeof (lwpstat.pr_reg);
7597   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7598 #endif
7599
7600   sect->flags = SEC_HAS_CONTENTS;
7601   sect->alignment_power = 2;
7602
7603   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7604     return FALSE;
7605
7606   /* Make a ".reg2/999" section */
7607
7608   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7609   len = strlen (buf) + 1;
7610   name = bfd_alloc (abfd, len);
7611   if (name == NULL)
7612     return FALSE;
7613   memcpy (name, buf, len);
7614
7615   sect = bfd_make_section_anyway (abfd, name);
7616   if (sect == NULL)
7617     return FALSE;
7618
7619 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7620   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7621   sect->filepos = note->descpos
7622     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7623 #endif
7624
7625 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7626   sect->size = sizeof (lwpstat.pr_fpreg);
7627   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7628 #endif
7629
7630   sect->flags = SEC_HAS_CONTENTS;
7631   sect->alignment_power = 2;
7632
7633   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7634 }
7635 #endif /* defined (HAVE_LWPSTATUS_T) */
7636
7637 #if defined (HAVE_WIN32_PSTATUS_T)
7638 static bfd_boolean
7639 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7640 {
7641   char buf[30];
7642   char *name;
7643   size_t len;
7644   asection *sect;
7645   win32_pstatus_t pstatus;
7646
7647   if (note->descsz < sizeof (pstatus))
7648     return TRUE;
7649
7650   memcpy (&pstatus, note->descdata, sizeof (pstatus));
7651
7652   switch (pstatus.data_type)
7653     {
7654     case NOTE_INFO_PROCESS:
7655       /* FIXME: need to add ->core_command.  */
7656       elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7657       elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
7658       break;
7659
7660     case NOTE_INFO_THREAD:
7661       /* Make a ".reg/999" section.  */
7662       sprintf (buf, ".reg/%ld", (long) pstatus.data.thread_info.tid);
7663
7664       len = strlen (buf) + 1;
7665       name = bfd_alloc (abfd, len);
7666       if (name == NULL)
7667         return FALSE;
7668
7669       memcpy (name, buf, len);
7670
7671       sect = bfd_make_section_anyway (abfd, name);
7672       if (sect == NULL)
7673         return FALSE;
7674
7675       sect->size = sizeof (pstatus.data.thread_info.thread_context);
7676       sect->filepos = (note->descpos
7677                        + offsetof (struct win32_pstatus,
7678                                    data.thread_info.thread_context));
7679       sect->flags = SEC_HAS_CONTENTS;
7680       sect->alignment_power = 2;
7681
7682       if (pstatus.data.thread_info.is_active_thread)
7683         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7684           return FALSE;
7685       break;
7686
7687     case NOTE_INFO_MODULE:
7688       /* Make a ".module/xxxxxxxx" section.  */
7689       sprintf (buf, ".module/%08lx",
7690                (long) pstatus.data.module_info.base_address);
7691
7692       len = strlen (buf) + 1;
7693       name = bfd_alloc (abfd, len);
7694       if (name == NULL)
7695         return FALSE;
7696
7697       memcpy (name, buf, len);
7698
7699       sect = bfd_make_section_anyway (abfd, name);
7700
7701       if (sect == NULL)
7702         return FALSE;
7703
7704       sect->size = note->descsz;
7705       sect->filepos = note->descpos;
7706       sect->flags = SEC_HAS_CONTENTS;
7707       sect->alignment_power = 2;
7708       break;
7709
7710     default:
7711       return TRUE;
7712     }
7713
7714   return TRUE;
7715 }
7716 #endif /* HAVE_WIN32_PSTATUS_T */
7717
7718 static bfd_boolean
7719 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7720 {
7721   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7722
7723   switch (note->type)
7724     {
7725     default:
7726       return TRUE;
7727
7728     case NT_PRSTATUS:
7729       if (bed->elf_backend_grok_prstatus)
7730         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7731           return TRUE;
7732 #if defined (HAVE_PRSTATUS_T)
7733       return elfcore_grok_prstatus (abfd, note);
7734 #else
7735       return TRUE;
7736 #endif
7737
7738 #if defined (HAVE_PSTATUS_T)
7739     case NT_PSTATUS:
7740       return elfcore_grok_pstatus (abfd, note);
7741 #endif
7742
7743 #if defined (HAVE_LWPSTATUS_T)
7744     case NT_LWPSTATUS:
7745       return elfcore_grok_lwpstatus (abfd, note);
7746 #endif
7747
7748     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
7749       return elfcore_grok_prfpreg (abfd, note);
7750
7751 #if defined (HAVE_WIN32_PSTATUS_T)
7752     case NT_WIN32PSTATUS:
7753       return elfcore_grok_win32pstatus (abfd, note);
7754 #endif
7755
7756     case NT_PRXFPREG:           /* Linux SSE extension */
7757       if (note->namesz == 6
7758           && strcmp (note->namedata, "LINUX") == 0)
7759         return elfcore_grok_prxfpreg (abfd, note);
7760       else
7761         return TRUE;
7762
7763     case NT_PRPSINFO:
7764     case NT_PSINFO:
7765       if (bed->elf_backend_grok_psinfo)
7766         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7767           return TRUE;
7768 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7769       return elfcore_grok_psinfo (abfd, note);
7770 #else
7771       return TRUE;
7772 #endif
7773
7774     case NT_AUXV:
7775       {
7776         asection *sect = bfd_make_section_anyway (abfd, ".auxv");
7777
7778         if (sect == NULL)
7779           return FALSE;
7780         sect->size = note->descsz;
7781         sect->filepos = note->descpos;
7782         sect->flags = SEC_HAS_CONTENTS;
7783         sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7784
7785         return TRUE;
7786       }
7787     }
7788 }
7789
7790 static bfd_boolean
7791 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7792 {
7793   char *cp;
7794
7795   cp = strchr (note->namedata, '@');
7796   if (cp != NULL)
7797     {
7798       *lwpidp = atoi(cp + 1);
7799       return TRUE;
7800     }
7801   return FALSE;
7802 }
7803
7804 static bfd_boolean
7805 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
7806 {
7807
7808   /* Signal number at offset 0x08. */
7809   elf_tdata (abfd)->core_signal
7810     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7811
7812   /* Process ID at offset 0x50. */
7813   elf_tdata (abfd)->core_pid
7814     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7815
7816   /* Command name at 0x7c (max 32 bytes, including nul). */
7817   elf_tdata (abfd)->core_command
7818     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7819
7820   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7821                                           note);
7822 }
7823
7824 static bfd_boolean
7825 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
7826 {
7827   int lwp;
7828
7829   if (elfcore_netbsd_get_lwpid (note, &lwp))
7830     elf_tdata (abfd)->core_lwpid = lwp;
7831
7832   if (note->type == NT_NETBSDCORE_PROCINFO)
7833     {
7834       /* NetBSD-specific core "procinfo".  Note that we expect to
7835          find this note before any of the others, which is fine,
7836          since the kernel writes this note out first when it
7837          creates a core file.  */
7838
7839       return elfcore_grok_netbsd_procinfo (abfd, note);
7840     }
7841
7842   /* As of Jan 2002 there are no other machine-independent notes
7843      defined for NetBSD core files.  If the note type is less
7844      than the start of the machine-dependent note types, we don't
7845      understand it.  */
7846
7847   if (note->type < NT_NETBSDCORE_FIRSTMACH)
7848     return TRUE;
7849
7850
7851   switch (bfd_get_arch (abfd))
7852     {
7853     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7854        PT_GETFPREGS == mach+2.  */
7855
7856     case bfd_arch_alpha:
7857     case bfd_arch_sparc:
7858       switch (note->type)
7859         {
7860         case NT_NETBSDCORE_FIRSTMACH+0:
7861           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7862
7863         case NT_NETBSDCORE_FIRSTMACH+2:
7864           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7865
7866         default:
7867           return TRUE;
7868         }
7869
7870     /* On all other arch's, PT_GETREGS == mach+1 and
7871        PT_GETFPREGS == mach+3.  */
7872
7873     default:
7874       switch (note->type)
7875         {
7876         case NT_NETBSDCORE_FIRSTMACH+1:
7877           return elfcore_make_note_pseudosection (abfd, ".reg", note);
7878
7879         case NT_NETBSDCORE_FIRSTMACH+3:
7880           return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7881
7882         default:
7883           return TRUE;
7884         }
7885     }
7886     /* NOTREACHED */
7887 }
7888
7889 static bfd_boolean
7890 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
7891 {
7892   void *ddata = note->descdata;
7893   char buf[100];
7894   char *name;
7895   asection *sect;
7896   short sig;
7897   unsigned flags;
7898
7899   /* nto_procfs_status 'pid' field is at offset 0.  */
7900   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
7901
7902   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
7903   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
7904
7905   /* nto_procfs_status 'flags' field is at offset 8.  */
7906   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
7907
7908   /* nto_procfs_status 'what' field is at offset 14.  */
7909   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
7910     {
7911       elf_tdata (abfd)->core_signal = sig;
7912       elf_tdata (abfd)->core_lwpid = *tid;
7913     }
7914
7915   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
7916      do not come from signals so we make sure we set the current
7917      thread just in case.  */
7918   if (flags & 0x00000080)
7919     elf_tdata (abfd)->core_lwpid = *tid;
7920
7921   /* Make a ".qnx_core_status/%d" section.  */
7922   sprintf (buf, ".qnx_core_status/%ld", (long) *tid);
7923
7924   name = bfd_alloc (abfd, strlen (buf) + 1);
7925   if (name == NULL)
7926     return FALSE;
7927   strcpy (name, buf);
7928
7929   sect = bfd_make_section_anyway (abfd, name);
7930   if (sect == NULL)
7931     return FALSE;
7932
7933   sect->size            = note->descsz;
7934   sect->filepos         = note->descpos;
7935   sect->flags           = SEC_HAS_CONTENTS;
7936   sect->alignment_power = 2;
7937
7938   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
7939 }
7940
7941 static bfd_boolean
7942 elfcore_grok_nto_regs (bfd *abfd,
7943                        Elf_Internal_Note *note,
7944                        pid_t tid,
7945                        char *base)
7946 {
7947   char buf[100];
7948   char *name;
7949   asection *sect;
7950
7951   /* Make a "(base)/%d" section.  */
7952   sprintf (buf, "%s/%ld", base, (long) tid);
7953
7954   name = bfd_alloc (abfd, strlen (buf) + 1);
7955   if (name == NULL)
7956     return FALSE;
7957   strcpy (name, buf);
7958
7959   sect = bfd_make_section_anyway (abfd, name);
7960   if (sect == NULL)
7961     return FALSE;
7962
7963   sect->size            = note->descsz;
7964   sect->filepos         = note->descpos;
7965   sect->flags           = SEC_HAS_CONTENTS;
7966   sect->alignment_power = 2;
7967
7968   /* This is the current thread.  */
7969   if (elf_tdata (abfd)->core_lwpid == tid)
7970     return elfcore_maybe_make_sect (abfd, base, sect);
7971
7972   return TRUE;
7973 }
7974
7975 #define BFD_QNT_CORE_INFO       7
7976 #define BFD_QNT_CORE_STATUS     8
7977 #define BFD_QNT_CORE_GREG       9
7978 #define BFD_QNT_CORE_FPREG      10
7979
7980 static bfd_boolean
7981 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
7982 {
7983   /* Every GREG section has a STATUS section before it.  Store the
7984      tid from the previous call to pass down to the next gregs
7985      function.  */
7986   static pid_t tid = 1;
7987
7988   switch (note->type)
7989     {
7990     case BFD_QNT_CORE_INFO:
7991       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7992     case BFD_QNT_CORE_STATUS:
7993       return elfcore_grok_nto_status (abfd, note, &tid);
7994     case BFD_QNT_CORE_GREG:
7995       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
7996     case BFD_QNT_CORE_FPREG:
7997       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
7998     default:
7999       return TRUE;
8000     }
8001 }
8002
8003 /* Function: elfcore_write_note
8004
8005    Inputs:
8006      buffer to hold note
8007      name of note
8008      type of note
8009      data for note
8010      size of data for note
8011
8012    Return:
8013    End of buffer containing note.  */
8014
8015 char *
8016 elfcore_write_note (bfd  *abfd,
8017                     char *buf,
8018                     int  *bufsiz,
8019                     const char *name,
8020                     int  type,
8021                     const void *input,
8022                     int  size)
8023 {
8024   Elf_External_Note *xnp;
8025   size_t namesz;
8026   size_t pad;
8027   size_t newspace;
8028   char *p, *dest;
8029
8030   namesz = 0;
8031   pad = 0;
8032   if (name != NULL)
8033     {
8034       const struct elf_backend_data *bed;
8035
8036       namesz = strlen (name) + 1;
8037       bed = get_elf_backend_data (abfd);
8038       pad = -namesz & ((1 << bed->s->log_file_align) - 1);
8039     }
8040
8041   newspace = 12 + namesz + pad + size;
8042
8043   p = realloc (buf, *bufsiz + newspace);
8044   dest = p + *bufsiz;
8045   *bufsiz += newspace;
8046   xnp = (Elf_External_Note *) dest;
8047   H_PUT_32 (abfd, namesz, xnp->namesz);
8048   H_PUT_32 (abfd, size, xnp->descsz);
8049   H_PUT_32 (abfd, type, xnp->type);
8050   dest = xnp->name;
8051   if (name != NULL)
8052     {
8053       memcpy (dest, name, namesz);
8054       dest += namesz;
8055       while (pad != 0)
8056         {
8057           *dest++ = '\0';
8058           --pad;
8059         }
8060     }
8061   memcpy (dest, input, size);
8062   return p;
8063 }
8064
8065 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8066 char *
8067 elfcore_write_prpsinfo (bfd  *abfd,
8068                         char *buf,
8069                         int  *bufsiz,
8070                         const char *fname,
8071                         const char *psargs)
8072 {
8073   int note_type;
8074   char *note_name = "CORE";
8075
8076 #if defined (HAVE_PSINFO_T)
8077   psinfo_t  data;
8078   note_type = NT_PSINFO;
8079 #else
8080   prpsinfo_t data;
8081   note_type = NT_PRPSINFO;
8082 #endif
8083
8084   memset (&data, 0, sizeof (data));
8085   strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8086   strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8087   return elfcore_write_note (abfd, buf, bufsiz,
8088                              note_name, note_type, &data, sizeof (data));
8089 }
8090 #endif  /* PSINFO_T or PRPSINFO_T */
8091
8092 #if defined (HAVE_PRSTATUS_T)
8093 char *
8094 elfcore_write_prstatus (bfd *abfd,
8095                         char *buf,
8096                         int *bufsiz,
8097                         long pid,
8098                         int cursig,
8099                         const void *gregs)
8100 {
8101   prstatus_t prstat;
8102   char *note_name = "CORE";
8103
8104   memset (&prstat, 0, sizeof (prstat));
8105   prstat.pr_pid = pid;
8106   prstat.pr_cursig = cursig;
8107   memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8108   return elfcore_write_note (abfd, buf, bufsiz,
8109                              note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
8110 }
8111 #endif /* HAVE_PRSTATUS_T */
8112
8113 #if defined (HAVE_LWPSTATUS_T)
8114 char *
8115 elfcore_write_lwpstatus (bfd *abfd,
8116                          char *buf,
8117                          int *bufsiz,
8118                          long pid,
8119                          int cursig,
8120                          const void *gregs)
8121 {
8122   lwpstatus_t lwpstat;
8123   char *note_name = "CORE";
8124
8125   memset (&lwpstat, 0, sizeof (lwpstat));
8126   lwpstat.pr_lwpid  = pid >> 16;
8127   lwpstat.pr_cursig = cursig;
8128 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8129   memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8130 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8131 #if !defined(gregs)
8132   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8133           gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8134 #else
8135   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8136           gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8137 #endif
8138 #endif
8139   return elfcore_write_note (abfd, buf, bufsiz, note_name,
8140                              NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8141 }
8142 #endif /* HAVE_LWPSTATUS_T */
8143
8144 #if defined (HAVE_PSTATUS_T)
8145 char *
8146 elfcore_write_pstatus (bfd *abfd,
8147                        char *buf,
8148                        int *bufsiz,
8149                        long pid,
8150                        int cursig ATTRIBUTE_UNUSED,
8151                        const void *gregs ATTRIBUTE_UNUSED)
8152 {
8153   pstatus_t pstat;
8154   char *note_name = "CORE";
8155
8156   memset (&pstat, 0, sizeof (pstat));
8157   pstat.pr_pid = pid & 0xffff;
8158   buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8159                             NT_PSTATUS, &pstat, sizeof (pstat));
8160   return buf;
8161 }
8162 #endif /* HAVE_PSTATUS_T */
8163
8164 char *
8165 elfcore_write_prfpreg (bfd *abfd,
8166                        char *buf,
8167                        int *bufsiz,
8168                        const void *fpregs,
8169                        int size)
8170 {
8171   char *note_name = "CORE";
8172   return elfcore_write_note (abfd, buf, bufsiz,
8173                              note_name, NT_FPREGSET, fpregs, size);
8174 }
8175
8176 char *
8177 elfcore_write_prxfpreg (bfd *abfd,
8178                         char *buf,
8179                         int *bufsiz,
8180                         const void *xfpregs,
8181                         int size)
8182 {
8183   char *note_name = "LINUX";
8184   return elfcore_write_note (abfd, buf, bufsiz,
8185                              note_name, NT_PRXFPREG, xfpregs, size);
8186 }
8187
8188 static bfd_boolean
8189 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
8190 {
8191   char *buf;
8192   char *p;
8193
8194   if (size <= 0)
8195     return TRUE;
8196
8197   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
8198     return FALSE;
8199
8200   buf = bfd_malloc (size);
8201   if (buf == NULL)
8202     return FALSE;
8203
8204   if (bfd_bread (buf, size, abfd) != size)
8205     {
8206     error:
8207       free (buf);
8208       return FALSE;
8209     }
8210
8211   p = buf;
8212   while (p < buf + size)
8213     {
8214       /* FIXME: bad alignment assumption.  */
8215       Elf_External_Note *xnp = (Elf_External_Note *) p;
8216       Elf_Internal_Note in;
8217
8218       in.type = H_GET_32 (abfd, xnp->type);
8219
8220       in.namesz = H_GET_32 (abfd, xnp->namesz);
8221       in.namedata = xnp->name;
8222
8223       in.descsz = H_GET_32 (abfd, xnp->descsz);
8224       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8225       in.descpos = offset + (in.descdata - buf);
8226
8227       if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
8228         {
8229           if (! elfcore_grok_netbsd_note (abfd, &in))
8230             goto error;
8231         }
8232       else if (strncmp (in.namedata, "QNX", 3) == 0)
8233         {
8234           if (! elfcore_grok_nto_note (abfd, &in))
8235             goto error;
8236         }
8237       else
8238         {
8239           if (! elfcore_grok_note (abfd, &in))
8240             goto error;
8241         }
8242
8243       p = in.descdata + BFD_ALIGN (in.descsz, 4);
8244     }
8245
8246   free (buf);
8247   return TRUE;
8248 }
8249 \f
8250 /* Providing external access to the ELF program header table.  */
8251
8252 /* Return an upper bound on the number of bytes required to store a
8253    copy of ABFD's program header table entries.  Return -1 if an error
8254    occurs; bfd_get_error will return an appropriate code.  */
8255
8256 long
8257 bfd_get_elf_phdr_upper_bound (bfd *abfd)
8258 {
8259   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8260     {
8261       bfd_set_error (bfd_error_wrong_format);
8262       return -1;
8263     }
8264
8265   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
8266 }
8267
8268 /* Copy ABFD's program header table entries to *PHDRS.  The entries
8269    will be stored as an array of Elf_Internal_Phdr structures, as
8270    defined in include/elf/internal.h.  To find out how large the
8271    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8272
8273    Return the number of program header table entries read, or -1 if an
8274    error occurs; bfd_get_error will return an appropriate code.  */
8275
8276 int
8277 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
8278 {
8279   int num_phdrs;
8280
8281   if (abfd->xvec->flavour != bfd_target_elf_flavour)
8282     {
8283       bfd_set_error (bfd_error_wrong_format);
8284       return -1;
8285     }
8286
8287   num_phdrs = elf_elfheader (abfd)->e_phnum;
8288   memcpy (phdrs, elf_tdata (abfd)->phdr,
8289           num_phdrs * sizeof (Elf_Internal_Phdr));
8290
8291   return num_phdrs;
8292 }
8293
8294 void
8295 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
8296 {
8297 #ifdef BFD64
8298   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
8299
8300   i_ehdrp = elf_elfheader (abfd);
8301   if (i_ehdrp == NULL)
8302     sprintf_vma (buf, value);
8303   else
8304     {
8305       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
8306         {
8307 #if BFD_HOST_64BIT_LONG
8308           sprintf (buf, "%016lx", value);
8309 #else
8310           sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
8311                    _bfd_int64_low (value));
8312 #endif
8313         }
8314       else
8315         sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
8316     }
8317 #else
8318   sprintf_vma (buf, value);
8319 #endif
8320 }
8321
8322 void
8323 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
8324 {
8325 #ifdef BFD64
8326   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
8327
8328   i_ehdrp = elf_elfheader (abfd);
8329   if (i_ehdrp == NULL)
8330     fprintf_vma ((FILE *) stream, value);
8331   else
8332     {
8333       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
8334         {
8335 #if BFD_HOST_64BIT_LONG
8336           fprintf ((FILE *) stream, "%016lx", value);
8337 #else
8338           fprintf ((FILE *) stream, "%08lx%08lx",
8339                    _bfd_int64_high (value), _bfd_int64_low (value));
8340 #endif
8341         }
8342       else
8343         fprintf ((FILE *) stream, "%08lx",
8344                  (unsigned long) (value & 0xffffffff));
8345     }
8346 #else
8347   fprintf_vma ((FILE *) stream, value);
8348 #endif
8349 }
8350
8351 enum elf_reloc_type_class
8352 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8353 {
8354   return reloc_class_normal;
8355 }
8356
8357 /* For RELA architectures, return the relocation value for a
8358    relocation against a local symbol.  */
8359
8360 bfd_vma
8361 _bfd_elf_rela_local_sym (bfd *abfd,
8362                          Elf_Internal_Sym *sym,
8363                          asection **psec,
8364                          Elf_Internal_Rela *rel)
8365 {
8366   asection *sec = *psec;
8367   bfd_vma relocation;
8368
8369   relocation = (sec->output_section->vma
8370                 + sec->output_offset
8371                 + sym->st_value);
8372   if ((sec->flags & SEC_MERGE)
8373       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8374       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8375     {
8376       rel->r_addend =
8377         _bfd_merged_section_offset (abfd, psec,
8378                                     elf_section_data (sec)->sec_info,
8379                                     sym->st_value + rel->r_addend);
8380       if (sec != *psec)
8381         {
8382           /* If we have changed the section, and our original section is
8383              marked with SEC_EXCLUDE, it means that the original
8384              SEC_MERGE section has been completely subsumed in some
8385              other SEC_MERGE section.  In this case, we need to leave
8386              some info around for --emit-relocs.  */
8387           if ((sec->flags & SEC_EXCLUDE) != 0)
8388             sec->kept_section = *psec;
8389           sec = *psec;
8390         }
8391       rel->r_addend -= relocation;
8392       rel->r_addend += sec->output_section->vma + sec->output_offset;
8393     }
8394   return relocation;
8395 }
8396
8397 bfd_vma
8398 _bfd_elf_rel_local_sym (bfd *abfd,
8399                         Elf_Internal_Sym *sym,
8400                         asection **psec,
8401                         bfd_vma addend)
8402 {
8403   asection *sec = *psec;
8404
8405   if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8406     return sym->st_value + addend;
8407
8408   return _bfd_merged_section_offset (abfd, psec,
8409                                      elf_section_data (sec)->sec_info,
8410                                      sym->st_value + addend);
8411 }
8412
8413 bfd_vma
8414 _bfd_elf_section_offset (bfd *abfd,
8415                          struct bfd_link_info *info,
8416                          asection *sec,
8417                          bfd_vma offset)
8418 {
8419   switch (sec->sec_info_type)
8420     {
8421     case ELF_INFO_TYPE_STABS:
8422       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8423                                        offset);
8424     case ELF_INFO_TYPE_EH_FRAME:
8425       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8426     default:
8427       return offset;
8428     }
8429 }
8430 \f
8431 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
8432    reconstruct an ELF file by reading the segments out of remote memory
8433    based on the ELF file header at EHDR_VMA and the ELF program headers it
8434    points to.  If not null, *LOADBASEP is filled in with the difference
8435    between the VMAs from which the segments were read, and the VMAs the
8436    file headers (and hence BFD's idea of each section's VMA) put them at.
8437
8438    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8439    remote memory at target address VMA into the local buffer at MYADDR; it
8440    should return zero on success or an `errno' code on failure.  TEMPL must
8441    be a BFD for an ELF target with the word size and byte order found in
8442    the remote memory.  */
8443
8444 bfd *
8445 bfd_elf_bfd_from_remote_memory
8446   (bfd *templ,
8447    bfd_vma ehdr_vma,
8448    bfd_vma *loadbasep,
8449    int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8450 {
8451   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8452     (templ, ehdr_vma, loadbasep, target_read_memory);
8453 }
8454 \f
8455 long
8456 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8457                                long symcount ATTRIBUTE_UNUSED,
8458                                asymbol **syms ATTRIBUTE_UNUSED,
8459                                long dynsymcount,
8460                                asymbol **dynsyms,
8461                                asymbol **ret)
8462 {
8463   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8464   asection *relplt;
8465   asymbol *s;
8466   const char *relplt_name;
8467   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8468   arelent *p;
8469   long count, i, n;
8470   size_t size;
8471   Elf_Internal_Shdr *hdr;
8472   char *names;
8473   asection *plt;
8474
8475   *ret = NULL;
8476
8477   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8478     return 0;
8479
8480   if (dynsymcount <= 0)
8481     return 0;
8482
8483   if (!bed->plt_sym_val)
8484     return 0;
8485
8486   relplt_name = bed->relplt_name;
8487   if (relplt_name == NULL)
8488     relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8489   relplt = bfd_get_section_by_name (abfd, relplt_name);
8490   if (relplt == NULL)
8491     return 0;
8492
8493   hdr = &elf_section_data (relplt)->this_hdr;
8494   if (hdr->sh_link != elf_dynsymtab (abfd)
8495       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8496     return 0;
8497
8498   plt = bfd_get_section_by_name (abfd, ".plt");
8499   if (plt == NULL)
8500     return 0;
8501
8502   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8503   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8504     return -1;
8505
8506   count = relplt->size / hdr->sh_entsize;
8507   size = count * sizeof (asymbol);
8508   p = relplt->relocation;
8509   for (i = 0; i < count; i++, s++, p++)
8510     size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8511
8512   s = *ret = bfd_malloc (size);
8513   if (s == NULL)
8514     return -1;
8515
8516   names = (char *) (s + count);
8517   p = relplt->relocation;
8518   n = 0;
8519   for (i = 0; i < count; i++, s++, p++)
8520     {
8521       size_t len;
8522       bfd_vma addr;
8523
8524       addr = bed->plt_sym_val (i, plt, p);
8525       if (addr == (bfd_vma) -1)
8526         continue;
8527
8528       *s = **p->sym_ptr_ptr;
8529       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
8530          we are defining a symbol, ensure one of them is set.  */
8531       if ((s->flags & BSF_LOCAL) == 0)
8532         s->flags |= BSF_GLOBAL;
8533       s->section = plt;
8534       s->value = addr - plt->vma;
8535       s->name = names;
8536       len = strlen ((*p->sym_ptr_ptr)->name);
8537       memcpy (names, (*p->sym_ptr_ptr)->name, len);
8538       names += len;
8539       memcpy (names, "@plt", sizeof ("@plt"));
8540       names += sizeof ("@plt");
8541       ++n;
8542     }
8543
8544   return n;
8545 }
8546
8547 /* Sort symbol by binding and section. We want to put definitions
8548    sorted by section at the beginning.  */
8549
8550 static int
8551 elf_sort_elf_symbol (const void *arg1, const void *arg2)
8552 {
8553   const Elf_Internal_Sym *s1;
8554   const Elf_Internal_Sym *s2;
8555   int shndx;
8556
8557   /* Make sure that undefined symbols are at the end.  */
8558   s1 = (const Elf_Internal_Sym *) arg1;
8559   if (s1->st_shndx == SHN_UNDEF)
8560     return 1;
8561   s2 = (const Elf_Internal_Sym *) arg2;
8562   if (s2->st_shndx == SHN_UNDEF)
8563     return -1;
8564
8565   /* Sorted by section index.  */
8566   shndx = s1->st_shndx - s2->st_shndx;
8567   if (shndx != 0)
8568     return shndx;
8569
8570   /* Sorted by binding.  */
8571   return ELF_ST_BIND (s1->st_info)  - ELF_ST_BIND (s2->st_info);
8572 }
8573
8574 struct elf_symbol
8575 {
8576   Elf_Internal_Sym *sym;
8577   const char *name;
8578 };
8579
8580 static int
8581 elf_sym_name_compare (const void *arg1, const void *arg2)
8582 {
8583   const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
8584   const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
8585   return strcmp (s1->name, s2->name);
8586 }
8587
8588 /* Check if 2 sections define the same set of local and global
8589    symbols.  */
8590
8591 bfd_boolean
8592 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2)
8593 {
8594   bfd *bfd1, *bfd2;
8595   const struct elf_backend_data *bed1, *bed2;
8596   Elf_Internal_Shdr *hdr1, *hdr2;
8597   bfd_size_type symcount1, symcount2;
8598   Elf_Internal_Sym *isymbuf1, *isymbuf2;
8599   Elf_Internal_Sym *isymstart1 = NULL, *isymstart2 = NULL, *isym;
8600   Elf_Internal_Sym *isymend;
8601   struct elf_symbol *symp, *symtable1 = NULL, *symtable2 = NULL;
8602   bfd_size_type count1, count2, i;
8603   int shndx1, shndx2;
8604   bfd_boolean result;
8605
8606   bfd1 = sec1->owner;
8607   bfd2 = sec2->owner;
8608
8609   /* If both are .gnu.linkonce sections, they have to have the same
8610      section name.  */
8611   if (strncmp (sec1->name, ".gnu.linkonce",
8612                sizeof ".gnu.linkonce" - 1) == 0
8613       && strncmp (sec2->name, ".gnu.linkonce",
8614                   sizeof ".gnu.linkonce" - 1) == 0)
8615     return strcmp (sec1->name + sizeof ".gnu.linkonce",
8616                    sec2->name + sizeof ".gnu.linkonce") == 0;
8617
8618   /* Both sections have to be in ELF.  */
8619   if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
8620       || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
8621     return FALSE;
8622
8623   if (elf_section_type (sec1) != elf_section_type (sec2))
8624     return FALSE;
8625
8626   if ((elf_section_flags (sec1) & SHF_GROUP) != 0
8627       && (elf_section_flags (sec2) & SHF_GROUP) != 0)
8628     {
8629       /* If both are members of section groups, they have to have the
8630          same group name.  */
8631       if (strcmp (elf_group_name (sec1), elf_group_name (sec2)) != 0)
8632         return FALSE;
8633     }
8634
8635   shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
8636   shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
8637   if (shndx1 == -1 || shndx2 == -1)
8638     return FALSE;
8639
8640   bed1 = get_elf_backend_data (bfd1);
8641   bed2 = get_elf_backend_data (bfd2);
8642   hdr1 = &elf_tdata (bfd1)->symtab_hdr;
8643   symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
8644   hdr2 = &elf_tdata (bfd2)->symtab_hdr;
8645   symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
8646
8647   if (symcount1 == 0 || symcount2 == 0)
8648     return FALSE;
8649
8650   isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
8651                                    NULL, NULL, NULL);
8652   isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
8653                                    NULL, NULL, NULL);
8654
8655   result = FALSE;
8656   if (isymbuf1 == NULL || isymbuf2 == NULL)
8657     goto done;
8658
8659   /* Sort symbols by binding and section. Global definitions are at
8660      the beginning.  */
8661   qsort (isymbuf1, symcount1, sizeof (Elf_Internal_Sym),
8662          elf_sort_elf_symbol);
8663   qsort (isymbuf2, symcount2, sizeof (Elf_Internal_Sym),
8664          elf_sort_elf_symbol);
8665
8666   /* Count definitions in the section.  */
8667   count1 = 0;
8668   for (isym = isymbuf1, isymend = isym + symcount1;
8669        isym < isymend; isym++)
8670     {
8671       if (isym->st_shndx == (unsigned int) shndx1)
8672         {
8673           if (count1 == 0)
8674             isymstart1 = isym;
8675           count1++;
8676         }
8677
8678       if (count1 && isym->st_shndx != (unsigned int) shndx1)
8679         break;
8680     }
8681
8682   count2 = 0;
8683   for (isym = isymbuf2, isymend = isym + symcount2;
8684        isym < isymend; isym++)
8685     {
8686       if (isym->st_shndx == (unsigned int) shndx2)
8687         {
8688           if (count2 == 0)
8689             isymstart2 = isym;
8690           count2++;
8691         }
8692
8693       if (count2 && isym->st_shndx != (unsigned int) shndx2)
8694         break;
8695     }
8696
8697   if (count1 == 0 || count2 == 0 || count1 != count2)
8698     goto done;
8699
8700   symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8701   symtable2 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8702
8703   if (symtable1 == NULL || symtable2 == NULL)
8704     goto done;
8705
8706   symp = symtable1;
8707   for (isym = isymstart1, isymend = isym + count1;
8708        isym < isymend; isym++)
8709     {
8710       symp->sym = isym;
8711       symp->name = bfd_elf_string_from_elf_section (bfd1,
8712                                                     hdr1->sh_link,
8713                                                     isym->st_name);
8714       symp++;
8715     }
8716
8717   symp = symtable2;
8718   for (isym = isymstart2, isymend = isym + count1;
8719        isym < isymend; isym++)
8720     {
8721       symp->sym = isym;
8722       symp->name = bfd_elf_string_from_elf_section (bfd2,
8723                                                     hdr2->sh_link,
8724                                                     isym->st_name);
8725       symp++;
8726     }
8727
8728   /* Sort symbol by name.  */
8729   qsort (symtable1, count1, sizeof (struct elf_symbol),
8730          elf_sym_name_compare);
8731   qsort (symtable2, count1, sizeof (struct elf_symbol),
8732          elf_sym_name_compare);
8733
8734   for (i = 0; i < count1; i++)
8735     /* Two symbols must have the same binding, type and name.  */
8736     if (symtable1 [i].sym->st_info != symtable2 [i].sym->st_info
8737         || symtable1 [i].sym->st_other != symtable2 [i].sym->st_other
8738         || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
8739       goto done;
8740
8741   result = TRUE;
8742
8743 done:
8744   if (symtable1)
8745     free (symtable1);
8746   if (symtable2)
8747     free (symtable2);
8748   if (isymbuf1)
8749     free (isymbuf1);
8750   if (isymbuf2)
8751     free (isymbuf2);
8752
8753   return result;
8754 }
8755
8756 /* It is only used by x86-64 so far.  */
8757 asection _bfd_elf_large_com_section
8758   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
8759                       SEC_IS_COMMON, NULL, NULL, "LARGE_COMMON",
8760                       0);
8761
8762 /* Return TRUE if 2 section types are compatible.  */
8763
8764 bfd_boolean
8765 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
8766                                  bfd *bbfd, const asection *bsec)
8767 {
8768   if (asec == NULL
8769       || bsec == NULL
8770       || abfd->xvec->flavour != bfd_target_elf_flavour
8771       || bbfd->xvec->flavour != bfd_target_elf_flavour)
8772     return TRUE;
8773
8774   return elf_section_type (asec) == elf_section_type (bsec);
8775 }