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