bfd/elf.c

   1 /* ELF executable support for BFD.
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  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
  35 /* For sparc64-cross-sparc32.  */
  36 #define _SYSCALL32
  37 #include "bfd.h"
  38 #include "sysdep.h"
  39 #include "bfdlink.h"
  40 #include "libbfd.h"
  41 #define ARCH_SIZE 0
  42 #include "elf-bfd.h"
  43
  44 static INLINE struct elf_segment_map *make_mapping
  45   PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
  46 static boolean map_sections_to_segments PARAMS ((bfd *));
  47 static int elf_sort_sections PARAMS ((const PTR, const PTR));
  48 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
  49 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
  50 static boolean prep_headers PARAMS ((bfd *));
  51 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
  52 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
  53 static char *elf_read PARAMS ((bfd *, long, unsigned int));
  54 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
  55 static boolean assign_section_numbers PARAMS ((bfd *));
  56 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
  57 static boolean elf_map_symbols PARAMS ((bfd *));
  58 static bfd_size_type get_program_header_size PARAMS ((bfd *));
  59 static boolean elfcore_read_notes PARAMS ((bfd *, bfd_vma, bfd_vma));
  60 static boolean elf_find_function PARAMS ((bfd *, asection *, asymbol **,
  61                                           bfd_vma, const char **,
  62                                           const char **));
  63 static int elfcore_make_pid PARAMS ((bfd *));
  64 static boolean elfcore_maybe_make_sect PARAMS ((bfd *, char *, asection *));
  65 static boolean elfcore_make_note_pseudosection PARAMS ((bfd *, char *,
  66                                                         Elf_Internal_Note *));
  67 static boolean elfcore_grok_prfpreg PARAMS ((bfd *, Elf_Internal_Note *));
  68 static boolean elfcore_grok_prxfpreg PARAMS ((bfd *, Elf_Internal_Note *));
  69 static boolean elfcore_grok_note PARAMS ((bfd *, Elf_Internal_Note *));
  70
  71 /* Swap version information in and out.  The version information is
  72    currently size independent.  If that ever changes, this code will
  73    need to move into elfcode.h.  */
  74
  75 /* Swap in a Verdef structure.  */
  76
  77 void
  78 _bfd_elf_swap_verdef_in (abfd, src, dst)
  79      bfd *abfd;
  80      const Elf_External_Verdef *src;
  81      Elf_Internal_Verdef *dst;
  82 {
  83   dst->vd_version = bfd_h_get_16 (abfd, src->vd_version);
  84   dst->vd_flags   = bfd_h_get_16 (abfd, src->vd_flags);
  85   dst->vd_ndx     = bfd_h_get_16 (abfd, src->vd_ndx);
  86   dst->vd_cnt     = bfd_h_get_16 (abfd, src->vd_cnt);
  87   dst->vd_hash    = bfd_h_get_32 (abfd, src->vd_hash);
  88   dst->vd_aux     = bfd_h_get_32 (abfd, src->vd_aux);
  89   dst->vd_next    = bfd_h_get_32 (abfd, src->vd_next);
  90 }
  91
  92 /* Swap out a Verdef structure.  */
  93
  94 void
  95 _bfd_elf_swap_verdef_out (abfd, src, dst)
  96      bfd *abfd;
  97      const Elf_Internal_Verdef *src;
  98      Elf_External_Verdef *dst;
  99 {
 100   bfd_h_put_16 (abfd, src->vd_version, dst->vd_version);
 101   bfd_h_put_16 (abfd, src->vd_flags, dst->vd_flags);
 102   bfd_h_put_16 (abfd, src->vd_ndx, dst->vd_ndx);
 103   bfd_h_put_16 (abfd, src->vd_cnt, dst->vd_cnt);
 104   bfd_h_put_32 (abfd, src->vd_hash, dst->vd_hash);
 105   bfd_h_put_32 (abfd, src->vd_aux, dst->vd_aux);
 106   bfd_h_put_32 (abfd, src->vd_next, dst->vd_next);
 107 }
 108
 109 /* Swap in a Verdaux structure.  */
 110
 111 void
 112 _bfd_elf_swap_verdaux_in (abfd, src, dst)
 113      bfd *abfd;
 114      const Elf_External_Verdaux *src;
 115      Elf_Internal_Verdaux *dst;
 116 {
 117   dst->vda_name = bfd_h_get_32 (abfd, src->vda_name);
 118   dst->vda_next = bfd_h_get_32 (abfd, src->vda_next);
 119 }
 120
 121 /* Swap out a Verdaux structure.  */
 122
 123 void
 124 _bfd_elf_swap_verdaux_out (abfd, src, dst)
 125      bfd *abfd;
 126      const Elf_Internal_Verdaux *src;
 127      Elf_External_Verdaux *dst;
 128 {
 129   bfd_h_put_32 (abfd, src->vda_name, dst->vda_name);
 130   bfd_h_put_32 (abfd, src->vda_next, dst->vda_next);
 131 }
 132
 133 /* Swap in a Verneed structure.  */
 134
 135 void
 136 _bfd_elf_swap_verneed_in (abfd, src, dst)
 137      bfd *abfd;
 138      const Elf_External_Verneed *src;
 139      Elf_Internal_Verneed *dst;
 140 {
 141   dst->vn_version = bfd_h_get_16 (abfd, src->vn_version);
 142   dst->vn_cnt     = bfd_h_get_16 (abfd, src->vn_cnt);
 143   dst->vn_file    = bfd_h_get_32 (abfd, src->vn_file);
 144   dst->vn_aux     = bfd_h_get_32 (abfd, src->vn_aux);
 145   dst->vn_next    = bfd_h_get_32 (abfd, src->vn_next);
 146 }
 147
 148 /* Swap out a Verneed structure.  */
 149
 150 void
 151 _bfd_elf_swap_verneed_out (abfd, src, dst)
 152      bfd *abfd;
 153      const Elf_Internal_Verneed *src;
 154      Elf_External_Verneed *dst;
 155 {
 156   bfd_h_put_16 (abfd, src->vn_version, dst->vn_version);
 157   bfd_h_put_16 (abfd, src->vn_cnt, dst->vn_cnt);
 158   bfd_h_put_32 (abfd, src->vn_file, dst->vn_file);
 159   bfd_h_put_32 (abfd, src->vn_aux, dst->vn_aux);
 160   bfd_h_put_32 (abfd, src->vn_next, dst->vn_next);
 161 }
 162
 163 /* Swap in a Vernaux structure.  */
 164
 165 void
 166 _bfd_elf_swap_vernaux_in (abfd, src, dst)
 167      bfd *abfd;
 168      const Elf_External_Vernaux *src;
 169      Elf_Internal_Vernaux *dst;
 170 {
 171   dst->vna_hash  = bfd_h_get_32 (abfd, src->vna_hash);
 172   dst->vna_flags = bfd_h_get_16 (abfd, src->vna_flags);
 173   dst->vna_other = bfd_h_get_16 (abfd, src->vna_other);
 174   dst->vna_name  = bfd_h_get_32 (abfd, src->vna_name);
 175   dst->vna_next  = bfd_h_get_32 (abfd, src->vna_next);
 176 }
 177
 178 /* Swap out a Vernaux structure.  */
 179
 180 void
 181 _bfd_elf_swap_vernaux_out (abfd, src, dst)
 182      bfd *abfd;
 183      const Elf_Internal_Vernaux *src;
 184      Elf_External_Vernaux *dst;
 185 {
 186   bfd_h_put_32 (abfd, src->vna_hash, dst->vna_hash);
 187   bfd_h_put_16 (abfd, src->vna_flags, dst->vna_flags);
 188   bfd_h_put_16 (abfd, src->vna_other, dst->vna_other);
 189   bfd_h_put_32 (abfd, src->vna_name, dst->vna_name);
 190   bfd_h_put_32 (abfd, src->vna_next, dst->vna_next);
 191 }
 192
 193 /* Swap in a Versym structure.  */
 194
 195 void
 196 _bfd_elf_swap_versym_in (abfd, src, dst)
 197      bfd *abfd;
 198      const Elf_External_Versym *src;
 199      Elf_Internal_Versym *dst;
 200 {
 201   dst->vs_vers = bfd_h_get_16 (abfd, src->vs_vers);
 202 }
 203
 204 /* Swap out a Versym structure.  */
 205
 206 void
 207 _bfd_elf_swap_versym_out (abfd, src, dst)
 208      bfd *abfd;
 209      const Elf_Internal_Versym *src;
 210      Elf_External_Versym *dst;
 211 {
 212   bfd_h_put_16 (abfd, src->vs_vers, dst->vs_vers);
 213 }
 214
 215 /* Standard ELF hash function.  Do not change this function; you will
 216    cause invalid hash tables to be generated.  */
 217
 218 unsigned long
 219 bfd_elf_hash (namearg)
 220      const char *namearg;
 221 {
 222   const unsigned char *name = (const unsigned char *) namearg;
 223   unsigned long h = 0;
 224   unsigned long g;
 225   int ch;
 226
 227   while ((ch = *name++) != '\0')
 228     {
 229       h = (h << 4) + ch;
 230       if ((g = (h & 0xf0000000)) != 0)
 231         {
 232           h ^= g >> 24;
 233           /* The ELF ABI says `h &= ~g', but this is equivalent in
 234              this case and on some machines one insn instead of two.  */
 235           h ^= g;
 236         }
 237     }
 238   return h;
 239 }
 240
 241 /* Read a specified number of bytes at a specified offset in an ELF
 242    file, into a newly allocated buffer, and return a pointer to the
 243    buffer.  */
 244
 245 static char *
 246 elf_read (abfd, offset, size)
 247      bfd *abfd;
 248      long offset;
 249      unsigned int size;
 250 {
 251   char *buf;
 252
 253   if ((buf = bfd_alloc (abfd, size)) == NULL)
 254     return NULL;
 255   if (bfd_seek (abfd, offset, SEEK_SET) == -1)
 256     return NULL;
 257   if (bfd_read ((PTR) buf, size, 1, abfd) != size)
 258     {
 259       if (bfd_get_error () != bfd_error_system_call)
 260         bfd_set_error (bfd_error_file_truncated);
 261       return NULL;
 262     }
 263   return buf;
 264 }
 265
 266 boolean
 267 bfd_elf_mkobject (abfd)
 268      bfd *abfd;
 269 {
 270   /* This just does initialization.  */
 271   /* coff_mkobject zalloc's space for tdata.coff_obj_data ...  */
 272   elf_tdata (abfd) = (struct elf_obj_tdata *)
 273     bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
 274   if (elf_tdata (abfd) == 0)
 275     return false;
 276   /* Since everything is done at close time, do we need any
 277      initialization?  */
 278
 279   return true;
 280 }
 281
 282 boolean
 283 bfd_elf_mkcorefile (abfd)
 284      bfd *abfd;
 285 {
 286   /* I think this can be done just like an object file.  */
 287   return bfd_elf_mkobject (abfd);
 288 }
 289
 290 char *
 291 bfd_elf_get_str_section (abfd, shindex)
 292      bfd *abfd;
 293      unsigned int shindex;
 294 {
 295   Elf_Internal_Shdr **i_shdrp;
 296   char *shstrtab = NULL;
 297   unsigned int offset;
 298   unsigned int shstrtabsize;
 299
 300   i_shdrp = elf_elfsections (abfd);
 301   if (i_shdrp == 0 || i_shdrp[shindex] == 0)
 302     return 0;
 303
 304   shstrtab = (char *) i_shdrp[shindex]->contents;
 305   if (shstrtab == NULL)
 306     {
 307       /* No cached one, attempt to read, and cache what we read.  */
 308       offset = i_shdrp[shindex]->sh_offset;
 309       shstrtabsize = i_shdrp[shindex]->sh_size;
 310       shstrtab = elf_read (abfd, offset, shstrtabsize);
 311       i_shdrp[shindex]->contents = (PTR) shstrtab;
 312     }
 313   return shstrtab;
 314 }
 315
 316 char *
 317 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
 318      bfd *abfd;
 319      unsigned int shindex;
 320      unsigned int strindex;
 321 {
 322   Elf_Internal_Shdr *hdr;
 323
 324   if (strindex == 0)
 325     return "";
 326
 327   hdr = elf_elfsections (abfd)[shindex];
 328
 329   if (hdr->contents == NULL
 330       && bfd_elf_get_str_section (abfd, shindex) == NULL)
 331     return NULL;
 332
 333   if (strindex >= hdr->sh_size)
 334     {
 335       (*_bfd_error_handler)
 336         (_("%s: invalid string offset %u >= %lu for section `%s'"),
 337          bfd_get_filename (abfd), strindex, (unsigned long) hdr->sh_size,
 338          ((shindex == elf_elfheader(abfd)->e_shstrndx
 339            && strindex == hdr->sh_name)
 340           ? ".shstrtab"
 341           : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
 342       return "";
 343     }
 344
 345   return ((char *) hdr->contents) + strindex;
 346 }
 347
 348 /* Make a BFD section from an ELF section.  We store a pointer to the
 349    BFD section in the bfd_section field of the header.  */
 350
 351 boolean
 352 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
 353      bfd *abfd;
 354      Elf_Internal_Shdr *hdr;
 355      const char *name;
 356 {
 357   asection *newsect;
 358   flagword flags;
 359   struct elf_backend_data *bed;
 360
 361   if (hdr->bfd_section != NULL)
 362     {
 363       BFD_ASSERT (strcmp (name,
 364                           bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
 365       return true;
 366     }
 367
 368   newsect = bfd_make_section_anyway (abfd, name);
 369   if (newsect == NULL)
 370     return false;
 371
 372   newsect->filepos = hdr->sh_offset;
 373
 374   if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
 375       || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
 376       || ! bfd_set_section_alignment (abfd, newsect,
 377                                       bfd_log2 (hdr->sh_addralign)))
 378     return false;
 379
 380   flags = SEC_NO_FLAGS;
 381   if (hdr->sh_type != SHT_NOBITS)
 382     flags |= SEC_HAS_CONTENTS;
 383   if ((hdr->sh_flags & SHF_ALLOC) != 0)
 384     {
 385       flags |= SEC_ALLOC;
 386       if (hdr->sh_type != SHT_NOBITS)
 387         flags |= SEC_LOAD;
 388     }
 389   if ((hdr->sh_flags & SHF_WRITE) == 0)
 390     flags |= SEC_READONLY;
 391   if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
 392     flags |= SEC_CODE;
 393   else if ((flags & SEC_LOAD) != 0)
 394     flags |= SEC_DATA;
 395   if ((hdr->sh_flags & SHF_MERGE) != 0)
 396     {
 397       flags |= SEC_MERGE;
 398       newsect->entsize = hdr->sh_entsize;
 399       if ((hdr->sh_flags & SHF_STRINGS) != 0)
 400         flags |= SEC_STRINGS;
 401     }
 402
 403   /* The debugging sections appear to be recognized only by name, not
 404      any sort of flag.  */
 405   {
 406     static const char *debug_sec_names [] =
 407     {
 408       ".debug",
 409       ".gnu.linkonce.wi.",
 410       ".line",
 411       ".stab"
 412     };
 413     int i;
 414
 415     for (i = sizeof (debug_sec_names) / sizeof (debug_sec_names[0]); i--;)
 416       if (strncmp (name, debug_sec_names[i], strlen (debug_sec_names[i])) == 0)
 417         break;
 418
 419     if (i >= 0)
 420       flags |= SEC_DEBUGGING;
 421   }
 422
 423   /* As a GNU extension, if the name begins with .gnu.linkonce, we
 424      only link a single copy of the section.  This is used to support
 425      g++.  g++ will emit each template expansion in its own section.
 426      The symbols will be defined as weak, so that multiple definitions
 427      are permitted.  The GNU linker extension is to actually discard
 428      all but one of the sections.  */
 429   if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
 430     flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 431
 432   bed = get_elf_backend_data (abfd);
 433   if (bed->elf_backend_section_flags)
 434     if (! bed->elf_backend_section_flags (&flags, hdr))
 435       return false;
 436
 437   if (! bfd_set_section_flags (abfd, newsect, flags))
 438     return false;
 439
 440   if ((flags & SEC_ALLOC) != 0)
 441     {
 442       Elf_Internal_Phdr *phdr;
 443       unsigned int i;
 444
 445       /* Look through the phdrs to see if we need to adjust the lma.
 446          If all the p_paddr fields are zero, we ignore them, since
 447          some ELF linkers produce such output.  */
 448       phdr = elf_tdata (abfd)->phdr;
 449       for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
 450         {
 451           if (phdr->p_paddr != 0)
 452             break;
 453         }
 454       if (i < elf_elfheader (abfd)->e_phnum)
 455         {
 456           phdr = elf_tdata (abfd)->phdr;
 457           for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
 458             {
 459               if (phdr->p_type == PT_LOAD
 460                   && phdr->p_vaddr != phdr->p_paddr
 461                   && phdr->p_vaddr <= hdr->sh_addr
 462                   && (phdr->p_vaddr + phdr->p_memsz
 463                       >= hdr->sh_addr + hdr->sh_size)
 464                   && ((flags & SEC_LOAD) == 0
 465                       || (phdr->p_offset <= (bfd_vma) hdr->sh_offset
 466                           && (phdr->p_offset + phdr->p_filesz
 467                               >= hdr->sh_offset + hdr->sh_size))))
 468                 {
 469                   newsect->lma += phdr->p_paddr - phdr->p_vaddr;
 470                   break;
 471                 }
 472             }
 473         }
 474     }
 475
 476   hdr->bfd_section = newsect;
 477   elf_section_data (newsect)->this_hdr = *hdr;
 478
 479   return true;
 480 }
 481
 482 /*
 483 INTERNAL_FUNCTION
 484         bfd_elf_find_section
 485
 486 SYNOPSIS
 487         struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
 488
 489 DESCRIPTION
 490         Helper functions for GDB to locate the string tables.
 491         Since BFD hides string tables from callers, GDB needs to use an
 492         internal hook to find them.  Sun's .stabstr, in particular,
 493         isn't even pointed to by the .stab section, so ordinary
 494         mechanisms wouldn't work to find it, even if we had some.
 495 */
 496
 497 struct elf_internal_shdr *
 498 bfd_elf_find_section (abfd, name)
 499      bfd *abfd;
 500      char *name;
 501 {
 502   Elf_Internal_Shdr **i_shdrp;
 503   char *shstrtab;
 504   unsigned int max;
 505   unsigned int i;
 506
 507   i_shdrp = elf_elfsections (abfd);
 508   if (i_shdrp != NULL)
 509     {
 510       shstrtab = bfd_elf_get_str_section
 511         (abfd, elf_elfheader (abfd)->e_shstrndx);
 512       if (shstrtab != NULL)
 513         {
 514           max = elf_elfheader (abfd)->e_shnum;
 515           for (i = 1; i < max; i++)
 516             if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
 517               return i_shdrp[i];
 518         }
 519     }
 520   return 0;
 521 }
 522
 523 const char *const bfd_elf_section_type_names[] = {
 524   "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
 525   "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
 526   "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
 527 };
 528
 529 /* ELF relocs are against symbols.  If we are producing relocateable
 530    output, and the reloc is against an external symbol, and nothing
 531    has given us any additional addend, the resulting reloc will also
 532    be against the same symbol.  In such a case, we don't want to
 533    change anything about the way the reloc is handled, since it will
 534    all be done at final link time.  Rather than put special case code
 535    into bfd_perform_relocation, all the reloc types use this howto
 536    function.  It just short circuits the reloc if producing
 537    relocateable output against an external symbol.  */
 538
 539 bfd_reloc_status_type
 540 bfd_elf_generic_reloc (abfd,
 541                        reloc_entry,
 542                        symbol,
 543                        data,
 544                        input_section,
 545                        output_bfd,
 546                        error_message)
 547      bfd *abfd ATTRIBUTE_UNUSED;
 548      arelent *reloc_entry;
 549      asymbol *symbol;
 550      PTR data ATTRIBUTE_UNUSED;
 551      asection *input_section;
 552      bfd *output_bfd;
 553      char **error_message ATTRIBUTE_UNUSED;
 554 {
 555   if (output_bfd != (bfd *) NULL
 556       && (symbol->flags & BSF_SECTION_SYM) == 0
 557       && (! reloc_entry->howto->partial_inplace
 558           || reloc_entry->addend == 0))
 559     {
 560       reloc_entry->address += input_section->output_offset;
 561       return bfd_reloc_ok;
 562     }
 563
 564   return bfd_reloc_continue;
 565 }
 566 \f
 567 /* Finish SHF_MERGE section merging.  */
 568
 569 boolean
 570 _bfd_elf_merge_sections (abfd, info)
 571      bfd *abfd;
 572      struct bfd_link_info *info;
 573 {
 574   if (!is_elf_hash_table (info))
 575     return false;
 576   if (elf_hash_table (info)->merge_info)
 577     _bfd_merge_sections (abfd, elf_hash_table (info)->merge_info);
 578   return true;
 579 }
 580 \f
 581 /* Print out the program headers.  */
 582
 583 boolean
 584 _bfd_elf_print_private_bfd_data (abfd, farg)
 585      bfd *abfd;
 586      PTR farg;
 587 {
 588   FILE *f = (FILE *) farg;
 589   Elf_Internal_Phdr *p;
 590   asection *s;
 591   bfd_byte *dynbuf = NULL;
 592
 593   p = elf_tdata (abfd)->phdr;
 594   if (p != NULL)
 595     {
 596       unsigned int i, c;
 597
 598       fprintf (f, _("\nProgram Header:\n"));
 599       c = elf_elfheader (abfd)->e_phnum;
 600       for (i = 0; i < c; i++, p++)
 601         {
 602           const char *s;
 603           char buf[20];
 604
 605           switch (p->p_type)
 606             {
 607             case PT_NULL: s = "NULL"; break;
 608             case PT_LOAD: s = "LOAD"; break;
 609             case PT_DYNAMIC: s = "DYNAMIC"; break;
 610             case PT_INTERP: s = "INTERP"; break;
 611             case PT_NOTE: s = "NOTE"; break;
 612             case PT_SHLIB: s = "SHLIB"; break;
 613             case PT_PHDR: s = "PHDR"; break;
 614             default: sprintf (buf, "0x%lx", p->p_type); s = buf; break;
 615             }
 616           fprintf (f, "%8s off    0x", s);
 617           bfd_fprintf_vma (abfd, f, p->p_offset);
 618           fprintf (f, " vaddr 0x");
 619           bfd_fprintf_vma (abfd, f, p->p_vaddr);
 620           fprintf (f, " paddr 0x");
 621           bfd_fprintf_vma (abfd, f, p->p_paddr);
 622           fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
 623           fprintf (f, "         filesz 0x");
 624           bfd_fprintf_vma (abfd, f, p->p_filesz);
 625           fprintf (f, " memsz 0x");
 626           bfd_fprintf_vma (abfd, f, p->p_memsz);
 627           fprintf (f, " flags %c%c%c",
 628                    (p->p_flags & PF_R) != 0 ? 'r' : '-',
 629                    (p->p_flags & PF_W) != 0 ? 'w' : '-',
 630                    (p->p_flags & PF_X) != 0 ? 'x' : '-');
 631           if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0)
 632             fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X));
 633           fprintf (f, "\n");
 634         }
 635     }
 636
 637   s = bfd_get_section_by_name (abfd, ".dynamic");
 638   if (s != NULL)
 639     {
 640       int elfsec;
 641       unsigned long link;
 642       bfd_byte *extdyn, *extdynend;
 643       size_t extdynsize;
 644       void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
 645
 646       fprintf (f, _("\nDynamic Section:\n"));
 647
 648       dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
 649       if (dynbuf == NULL)
 650         goto error_return;
 651       if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
 652                                       s->_raw_size))
 653         goto error_return;
 654
 655       elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
 656       if (elfsec == -1)
 657         goto error_return;
 658       link = elf_elfsections (abfd)[elfsec]->sh_link;
 659
 660       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
 661       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
 662
 663       extdyn = dynbuf;
 664       extdynend = extdyn + s->_raw_size;
 665       for (; extdyn < extdynend; extdyn += extdynsize)
 666         {
 667           Elf_Internal_Dyn dyn;
 668           const char *name;
 669           char ab[20];
 670           boolean stringp;
 671
 672           (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
 673
 674           if (dyn.d_tag == DT_NULL)
 675             break;
 676
 677           stringp = false;
 678           switch (dyn.d_tag)
 679             {
 680             default:
 681               sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
 682               name = ab;
 683               break;
 684
 685             case DT_NEEDED: name = "NEEDED"; stringp = true; break;
 686             case DT_PLTRELSZ: name = "PLTRELSZ"; break;
 687             case DT_PLTGOT: name = "PLTGOT"; break;
 688             case DT_HASH: name = "HASH"; break;
 689             case DT_STRTAB: name = "STRTAB"; break;
 690             case DT_SYMTAB: name = "SYMTAB"; break;
 691             case DT_RELA: name = "RELA"; break;
 692             case DT_RELASZ: name = "RELASZ"; break;
 693             case DT_RELAENT: name = "RELAENT"; break;
 694             case DT_STRSZ: name = "STRSZ"; break;
 695             case DT_SYMENT: name = "SYMENT"; break;
 696             case DT_INIT: name = "INIT"; break;
 697             case DT_FINI: name = "FINI"; break;
 698             case DT_SONAME: name = "SONAME"; stringp = true; break;
 699             case DT_RPATH: name = "RPATH"; stringp = true; break;
 700             case DT_SYMBOLIC: name = "SYMBOLIC"; break;
 701             case DT_REL: name = "REL"; break;
 702             case DT_RELSZ: name = "RELSZ"; break;
 703             case DT_RELENT: name = "RELENT"; break;
 704             case DT_PLTREL: name = "PLTREL"; break;
 705             case DT_DEBUG: name = "DEBUG"; break;
 706             case DT_TEXTREL: name = "TEXTREL"; break;
 707             case DT_JMPREL: name = "JMPREL"; break;
 708             case DT_BIND_NOW: name = "BIND_NOW"; break;
 709             case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
 710             case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
 711             case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
 712             case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
 713             case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
 714             case DT_FLAGS: name = "FLAGS"; break;
 715             case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
 716             case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
 717             case DT_CHECKSUM: name = "CHECKSUM"; break;
 718             case DT_PLTPADSZ: name = "PLTPADSZ"; break;
 719             case DT_MOVEENT: name = "MOVEENT"; break;
 720             case DT_MOVESZ: name = "MOVESZ"; break;
 721             case DT_FEATURE: name = "FEATURE"; break;
 722             case DT_POSFLAG_1: name = "POSFLAG_1"; break;
 723             case DT_SYMINSZ: name = "SYMINSZ"; break;
 724             case DT_SYMINENT: name = "SYMINENT"; break;
 725             case DT_CONFIG: name = "CONFIG"; stringp = true; break;
 726             case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
 727             case DT_AUDIT: name = "AUDIT"; stringp = true; break;
 728             case DT_PLTPAD: name = "PLTPAD"; break;
 729             case DT_MOVETAB: name = "MOVETAB"; break;
 730             case DT_SYMINFO: name = "SYMINFO"; break;
 731             case DT_RELACOUNT: name = "RELACOUNT"; break;
 732             case DT_RELCOUNT: name = "RELCOUNT"; break;
 733             case DT_FLAGS_1: name = "FLAGS_1"; break;
 734             case DT_VERSYM: name = "VERSYM"; break;
 735             case DT_VERDEF: name = "VERDEF"; break;
 736             case DT_VERDEFNUM: name = "VERDEFNUM"; break;
 737             case DT_VERNEED: name = "VERNEED"; break;
 738             case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
 739             case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
 740             case DT_USED: name = "USED"; break;
 741             case DT_FILTER: name = "FILTER"; stringp = true; break;
 742             }
 743
 744           fprintf (f, "  %-11s ", name);
 745           if (! stringp)
 746             fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
 747           else
 748             {
 749               const char *string;
 750
 751               string = bfd_elf_string_from_elf_section (abfd, link,
 752                                                         dyn.d_un.d_val);
 753               if (string == NULL)
 754                 goto error_return;
 755               fprintf (f, "%s", string);
 756             }
 757           fprintf (f, "\n");
 758         }
 759
 760       free (dynbuf);
 761       dynbuf = NULL;
 762     }
 763
 764   if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
 765       || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
 766     {
 767       if (! _bfd_elf_slurp_version_tables (abfd))
 768         return false;
 769     }
 770
 771   if (elf_dynverdef (abfd) != 0)
 772     {
 773       Elf_Internal_Verdef *t;
 774
 775       fprintf (f, _("\nVersion definitions:\n"));
 776       for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
 777         {
 778           fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
 779                    t->vd_flags, t->vd_hash, t->vd_nodename);
 780           if (t->vd_auxptr->vda_nextptr != NULL)
 781             {
 782               Elf_Internal_Verdaux *a;
 783
 784               fprintf (f, "\t");
 785               for (a = t->vd_auxptr->vda_nextptr;
 786                    a != NULL;
 787                    a = a->vda_nextptr)
 788                 fprintf (f, "%s ", a->vda_nodename);
 789               fprintf (f, "\n");
 790             }
 791         }
 792     }
 793
 794   if (elf_dynverref (abfd) != 0)
 795     {
 796       Elf_Internal_Verneed *t;
 797
 798       fprintf (f, _("\nVersion References:\n"));
 799       for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
 800         {
 801           Elf_Internal_Vernaux *a;
 802
 803           fprintf (f, _("  required from %s:\n"), t->vn_filename);
 804           for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
 805             fprintf (f, "    0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
 806                      a->vna_flags, a->vna_other, a->vna_nodename);
 807         }
 808     }
 809
 810   return true;
 811
 812  error_return:
 813   if (dynbuf != NULL)
 814     free (dynbuf);
 815   return false;
 816 }
 817
 818 /* Display ELF-specific fields of a symbol.  */
 819
 820 void
 821 bfd_elf_print_symbol (abfd, filep, symbol, how)
 822      bfd *abfd;
 823      PTR filep;
 824      asymbol *symbol;
 825      bfd_print_symbol_type how;
 826 {
 827   FILE *file = (FILE *) filep;
 828   switch (how)
 829     {
 830     case bfd_print_symbol_name:
 831       fprintf (file, "%s", symbol->name);
 832       break;
 833     case bfd_print_symbol_more:
 834       fprintf (file, "elf ");
 835       bfd_fprintf_vma (abfd, file, symbol->value);
 836       fprintf (file, " %lx", (long) symbol->flags);
 837       break;
 838     case bfd_print_symbol_all:
 839       {
 840         const char *section_name;
 841         const char *name = NULL;
 842         struct elf_backend_data *bed;
 843         unsigned char st_other;
 844
 845         section_name = symbol->section ? symbol->section->name : "(*none*)";
 846
 847         bed = get_elf_backend_data (abfd);
 848         if (bed->elf_backend_print_symbol_all)
 849           name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
 850
 851         if (name == NULL)
 852           {
 853             name = symbol->name;
 854             bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
 855           }
 856
 857         fprintf (file, " %s\t", section_name);
 858         /* Print the "other" value for a symbol.  For common symbols,
 859            we've already printed the size; now print the alignment.
 860            For other symbols, we have no specified alignment, and
 861            we've printed the address; now print the size.  */
 862         bfd_fprintf_vma (abfd, file,
 863                          (bfd_is_com_section (symbol->section)
 864                           ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value
 865                           : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size));
 866
 867         /* If we have version information, print it.  */
 868         if (elf_tdata (abfd)->dynversym_section != 0
 869             && (elf_tdata (abfd)->dynverdef_section != 0
 870                 || elf_tdata (abfd)->dynverref_section != 0))
 871           {
 872             unsigned int vernum;
 873             const char *version_string;
 874
 875             vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
 876
 877             if (vernum == 0)
 878               version_string = "";
 879             else if (vernum == 1)
 880               version_string = "Base";
 881             else if (vernum <= elf_tdata (abfd)->cverdefs)
 882               version_string =
 883                 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
 884             else
 885               {
 886                 Elf_Internal_Verneed *t;
 887
 888                 version_string = "";
 889                 for (t = elf_tdata (abfd)->verref;
 890                      t != NULL;
 891                      t = t->vn_nextref)
 892                   {
 893                     Elf_Internal_Vernaux *a;
 894
 895                     for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
 896                       {
 897                         if (a->vna_other == vernum)
 898                           {
 899                             version_string = a->vna_nodename;
 900                             break;
 901                           }
 902                       }
 903                   }
 904               }
 905
 906             if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
 907               fprintf (file, "  %-11s", version_string);
 908             else
 909               {
 910                 int i;
 911
 912                 fprintf (file, " (%s)", version_string);
 913                 for (i = 10 - strlen (version_string); i > 0; --i)
 914                   putc (' ', file);
 915               }
 916           }
 917
 918         /* If the st_other field is not zero, print it.  */
 919         st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
 920
 921         switch (st_other)
 922           {
 923           case 0: break;
 924           case STV_INTERNAL:  fprintf (file, " .internal");  break;
 925           case STV_HIDDEN:    fprintf (file, " .hidden");    break;
 926           case STV_PROTECTED: fprintf (file, " .protected"); break;
 927           default:
 928             /* Some other non-defined flags are also present, so print
 929                everything hex.  */
 930             fprintf (file, " 0x%02x", (unsigned int) st_other);
 931           }
 932
 933         fprintf (file, " %s", name);
 934       }
 935       break;
 936     }
 937 }
 938 \f
 939 /* Create an entry in an ELF linker hash table.  */
 940
 941 struct bfd_hash_entry *
 942 _bfd_elf_link_hash_newfunc (entry, table, string)
 943      struct bfd_hash_entry *entry;
 944      struct bfd_hash_table *table;
 945      const char *string;
 946 {
 947   struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
 948
 949   /* Allocate the structure if it has not already been allocated by a
 950      subclass.  */
 951   if (ret == (struct elf_link_hash_entry *) NULL)
 952     ret = ((struct elf_link_hash_entry *)
 953            bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
 954   if (ret == (struct elf_link_hash_entry *) NULL)
 955     return (struct bfd_hash_entry *) ret;
 956
 957   /* Call the allocation method of the superclass.  */
 958   ret = ((struct elf_link_hash_entry *)
 959          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 960                                  table, string));
 961   if (ret != (struct elf_link_hash_entry *) NULL)
 962     {
 963       /* Set local fields.  */
 964       ret->indx = -1;
 965       ret->size = 0;
 966       ret->dynindx = -1;
 967       ret->dynstr_index = 0;
 968       ret->weakdef = NULL;
 969       ret->got.offset = (bfd_vma) -1;
 970       ret->plt.offset = (bfd_vma) -1;
 971       ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
 972       ret->verinfo.verdef = NULL;
 973       ret->vtable_entries_used = NULL;
 974       ret->vtable_entries_size = 0;
 975       ret->vtable_parent = NULL;
 976       ret->type = STT_NOTYPE;
 977       ret->other = 0;
 978       /* Assume that we have been called by a non-ELF symbol reader.
 979          This flag is then reset by the code which reads an ELF input
 980          file.  This ensures that a symbol created by a non-ELF symbol
 981          reader will have the flag set correctly.  */
 982       ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
 983     }
 984
 985   return (struct bfd_hash_entry *) ret;
 986 }
 987
 988 /* Copy data from an indirect symbol to its direct symbol, hiding the
 989    old indirect symbol.  */
 990
 991 void
 992 _bfd_elf_link_hash_copy_indirect (dir, ind)
 993      struct elf_link_hash_entry *dir, *ind;
 994 {
 995   /* Copy down any references that we may have already seen to the
 996      symbol which just became indirect.  */
 997
 998   dir->elf_link_hash_flags |=
 999     (ind->elf_link_hash_flags
1000      & (ELF_LINK_HASH_REF_DYNAMIC
1001         | ELF_LINK_HASH_REF_REGULAR
1002         | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1003         | ELF_LINK_NON_GOT_REF));
1004
1005   /* Copy over the global and procedure linkage table offset entries.
1006      These may have been already set up by a check_relocs routine.  */
1007   if (dir->got.offset == (bfd_vma) -1)
1008     {
1009       dir->got.offset = ind->got.offset;
1010       ind->got.offset = (bfd_vma) -1;
1011     }
1012   BFD_ASSERT (ind->got.offset == (bfd_vma) -1);
1013
1014   if (dir->plt.offset == (bfd_vma) -1)
1015     {
1016       dir->plt.offset = ind->plt.offset;
1017       ind->plt.offset = (bfd_vma) -1;
1018     }
1019   BFD_ASSERT (ind->plt.offset == (bfd_vma) -1);
1020
1021   if (dir->dynindx == -1)
1022     {
1023       dir->dynindx = ind->dynindx;
1024       dir->dynstr_index = ind->dynstr_index;
1025       ind->dynindx = -1;
1026       ind->dynstr_index = 0;
1027     }
1028   BFD_ASSERT (ind->dynindx == -1);
1029 }
1030
1031 void
1032 _bfd_elf_link_hash_hide_symbol (info, h)
1033      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1034      struct elf_link_hash_entry *h;
1035 {
1036   h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1037   h->plt.offset = (bfd_vma) -1;
1038   if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
1039     h->dynindx = -1;
1040 }
1041
1042 /* Initialize an ELF linker hash table.  */
1043
1044 boolean
1045 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
1046      struct elf_link_hash_table *table;
1047      bfd *abfd;
1048      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
1049                                                 struct bfd_hash_table *,
1050                                                 const char *));
1051 {
1052   boolean ret;
1053
1054   table->dynamic_sections_created = false;
1055   table->dynobj = NULL;
1056   /* The first dynamic symbol is a dummy.  */
1057   table->dynsymcount = 1;
1058   table->dynstr = NULL;
1059   table->bucketcount = 0;
1060   table->needed = NULL;
1061   table->runpath = NULL;
1062   table->hgot = NULL;
1063   table->stab_info = NULL;
1064   table->merge_info = NULL;
1065   table->dynlocal = NULL;
1066   ret = _bfd_link_hash_table_init (& table->root, abfd, newfunc);
1067   table->root.type = bfd_link_elf_hash_table;
1068
1069   return ret;
1070 }
1071
1072 /* Create an ELF linker hash table.  */
1073
1074 struct bfd_link_hash_table *
1075 _bfd_elf_link_hash_table_create (abfd)
1076      bfd *abfd;
1077 {
1078   struct elf_link_hash_table *ret;
1079
1080   ret = ((struct elf_link_hash_table *)
1081          bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
1082   if (ret == (struct elf_link_hash_table *) NULL)
1083     return NULL;
1084
1085   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1086     {
1087       bfd_release (abfd, ret);
1088       return NULL;
1089     }
1090
1091   return &ret->root;
1092 }
1093
1094 /* This is a hook for the ELF emulation code in the generic linker to
1095    tell the backend linker what file name to use for the DT_NEEDED
1096    entry for a dynamic object.  The generic linker passes name as an
1097    empty string to indicate that no DT_NEEDED entry should be made.  */
1098
1099 void
1100 bfd_elf_set_dt_needed_name (abfd, name)
1101      bfd *abfd;
1102      const char *name;
1103 {
1104   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1105       && bfd_get_format (abfd) == bfd_object)
1106     elf_dt_name (abfd) = name;
1107 }
1108
1109 void
1110 bfd_elf_set_dt_needed_soname (abfd, name)
1111      bfd *abfd;
1112      const char *name;
1113 {
1114   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1115       && bfd_get_format (abfd) == bfd_object)
1116     elf_dt_soname (abfd) = name;
1117 }
1118
1119 /* Get the list of DT_NEEDED entries for a link.  This is a hook for
1120    the linker ELF emulation code.  */
1121
1122 struct bfd_link_needed_list *
1123 bfd_elf_get_needed_list (abfd, info)
1124      bfd *abfd ATTRIBUTE_UNUSED;
1125      struct bfd_link_info *info;
1126 {
1127   if (info->hash->creator->flavour != bfd_target_elf_flavour)
1128     return NULL;
1129   return elf_hash_table (info)->needed;
1130 }
1131
1132 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link.  This is a
1133    hook for the linker ELF emulation code.  */
1134
1135 struct bfd_link_needed_list *
1136 bfd_elf_get_runpath_list (abfd, info)
1137      bfd *abfd ATTRIBUTE_UNUSED;
1138      struct bfd_link_info *info;
1139 {
1140   if (info->hash->creator->flavour != bfd_target_elf_flavour)
1141     return NULL;
1142   return elf_hash_table (info)->runpath;
1143 }
1144
1145 /* Get the name actually used for a dynamic object for a link.  This
1146    is the SONAME entry if there is one.  Otherwise, it is the string
1147    passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
1148
1149 const char *
1150 bfd_elf_get_dt_soname (abfd)
1151      bfd *abfd;
1152 {
1153   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1154       && bfd_get_format (abfd) == bfd_object)
1155     return elf_dt_name (abfd);
1156   return NULL;
1157 }
1158
1159 /* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
1160    the ELF linker emulation code.  */
1161
1162 boolean
1163 bfd_elf_get_bfd_needed_list (abfd, pneeded)
1164      bfd *abfd;
1165      struct bfd_link_needed_list **pneeded;
1166 {
1167   asection *s;
1168   bfd_byte *dynbuf = NULL;
1169   int elfsec;
1170   unsigned long link;
1171   bfd_byte *extdyn, *extdynend;
1172   size_t extdynsize;
1173   void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1174
1175   *pneeded = NULL;
1176
1177   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1178       || bfd_get_format (abfd) != bfd_object)
1179     return true;
1180
1181   s = bfd_get_section_by_name (abfd, ".dynamic");
1182   if (s == NULL || s->_raw_size == 0)
1183     return true;
1184
1185   dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1186   if (dynbuf == NULL)
1187     goto error_return;
1188
1189   if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1190                                   s->_raw_size))
1191     goto error_return;
1192
1193   elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1194   if (elfsec == -1)
1195     goto error_return;
1196
1197   link = elf_elfsections (abfd)[elfsec]->sh_link;
1198
1199   extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1200   swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1201
1202   extdyn = dynbuf;
1203   extdynend = extdyn + s->_raw_size;
1204   for (; extdyn < extdynend; extdyn += extdynsize)
1205     {
1206       Elf_Internal_Dyn dyn;
1207
1208       (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1209
1210       if (dyn.d_tag == DT_NULL)
1211         break;
1212
1213       if (dyn.d_tag == DT_NEEDED)
1214         {
1215           const char *string;
1216           struct bfd_link_needed_list *l;
1217
1218           string = bfd_elf_string_from_elf_section (abfd, link,
1219                                                     dyn.d_un.d_val);
1220           if (string == NULL)
1221             goto error_return;
1222
1223           l = (struct bfd_link_needed_list *) bfd_alloc (abfd, sizeof *l);
1224           if (l == NULL)
1225             goto error_return;
1226
1227           l->by = abfd;
1228           l->name = string;
1229           l->next = *pneeded;
1230           *pneeded = l;
1231         }
1232     }
1233
1234   free (dynbuf);
1235
1236   return true;
1237
1238  error_return:
1239   if (dynbuf != NULL)
1240     free (dynbuf);
1241   return false;
1242 }
1243 \f
1244 /* Allocate an ELF string table--force the first byte to be zero.  */
1245
1246 struct bfd_strtab_hash *
1247 _bfd_elf_stringtab_init ()
1248 {
1249   struct bfd_strtab_hash *ret;
1250
1251   ret = _bfd_stringtab_init ();
1252   if (ret != NULL)
1253     {
1254       bfd_size_type loc;
1255
1256       loc = _bfd_stringtab_add (ret, "", true, false);
1257       BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1258       if (loc == (bfd_size_type) -1)
1259         {
1260           _bfd_stringtab_free (ret);
1261           ret = NULL;
1262         }
1263     }
1264   return ret;
1265 }
1266 \f
1267 /* ELF .o/exec file reading */
1268
1269 /* Create a new bfd section from an ELF section header.  */
1270
1271 boolean
1272 bfd_section_from_shdr (abfd, shindex)
1273      bfd *abfd;
1274      unsigned int shindex;
1275 {
1276   Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1277   Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1278   struct elf_backend_data *bed = get_elf_backend_data (abfd);
1279   char *name;
1280
1281   name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1282
1283   switch (hdr->sh_type)
1284     {
1285     case SHT_NULL:
1286       /* Inactive section. Throw it away.  */
1287       return true;
1288
1289     case SHT_PROGBITS:  /* Normal section with contents.  */
1290     case SHT_DYNAMIC:   /* Dynamic linking information.  */
1291     case SHT_NOBITS:    /* .bss section.  */
1292     case SHT_HASH:      /* .hash section.  */
1293     case SHT_NOTE:      /* .note section.  */
1294       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1295
1296     case SHT_SYMTAB:            /* A symbol table */
1297       if (elf_onesymtab (abfd) == shindex)
1298         return true;
1299
1300       BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1301       BFD_ASSERT (elf_onesymtab (abfd) == 0);
1302       elf_onesymtab (abfd) = shindex;
1303       elf_tdata (abfd)->symtab_hdr = *hdr;
1304       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1305       abfd->flags |= HAS_SYMS;
1306
1307       /* Sometimes a shared object will map in the symbol table.  If
1308          SHF_ALLOC is set, and this is a shared object, then we also
1309          treat this section as a BFD section.  We can not base the
1310          decision purely on SHF_ALLOC, because that flag is sometimes
1311          set in a relocateable object file, which would confuse the
1312          linker.  */
1313       if ((hdr->sh_flags & SHF_ALLOC) != 0
1314           && (abfd->flags & DYNAMIC) != 0
1315           && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1316         return false;
1317
1318       return true;
1319
1320     case SHT_DYNSYM:            /* A dynamic symbol table */
1321       if (elf_dynsymtab (abfd) == shindex)
1322         return true;
1323
1324       BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1325       BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1326       elf_dynsymtab (abfd) = shindex;
1327       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1328       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1329       abfd->flags |= HAS_SYMS;
1330
1331       /* Besides being a symbol table, we also treat this as a regular
1332          section, so that objcopy can handle it.  */
1333       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1334
1335     case SHT_STRTAB:            /* A string table */
1336       if (hdr->bfd_section != NULL)
1337         return true;
1338       if (ehdr->e_shstrndx == shindex)
1339         {
1340           elf_tdata (abfd)->shstrtab_hdr = *hdr;
1341           elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1342           return true;
1343         }
1344       {
1345         unsigned int i;
1346
1347         for (i = 1; i < ehdr->e_shnum; i++)
1348           {
1349             Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1350             if (hdr2->sh_link == shindex)
1351               {
1352                 if (! bfd_section_from_shdr (abfd, i))
1353                   return false;
1354                 if (elf_onesymtab (abfd) == i)
1355                   {
1356                     elf_tdata (abfd)->strtab_hdr = *hdr;
1357                     elf_elfsections (abfd)[shindex] =
1358                       &elf_tdata (abfd)->strtab_hdr;
1359                     return true;
1360                   }
1361                 if (elf_dynsymtab (abfd) == i)
1362                   {
1363                     elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1364                     elf_elfsections (abfd)[shindex] = hdr =
1365                       &elf_tdata (abfd)->dynstrtab_hdr;
1366                     /* We also treat this as a regular section, so
1367                        that objcopy can handle it.  */
1368                     break;
1369                   }
1370 #if 0 /* Not handling other string tables specially right now.  */
1371                 hdr2 = elf_elfsections (abfd)[i];       /* in case it moved */
1372                 /* We have a strtab for some random other section.  */
1373                 newsect = (asection *) hdr2->bfd_section;
1374                 if (!newsect)
1375                   break;
1376                 hdr->bfd_section = newsect;
1377                 hdr2 = &elf_section_data (newsect)->str_hdr;
1378                 *hdr2 = *hdr;
1379                 elf_elfsections (abfd)[shindex] = hdr2;
1380 #endif
1381               }
1382           }
1383       }
1384
1385       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1386
1387     case SHT_REL:
1388     case SHT_RELA:
1389       /* *These* do a lot of work -- but build no sections!  */
1390       {
1391         asection *target_sect;
1392         Elf_Internal_Shdr *hdr2;
1393
1394         /* Check for a bogus link to avoid crashing.  */
1395         if (hdr->sh_link >= ehdr->e_shnum)
1396           {
1397             ((*_bfd_error_handler)
1398              (_("%s: invalid link %lu for reloc section %s (index %u)"),
1399               bfd_get_filename (abfd), hdr->sh_link, name, shindex));
1400             return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1401           }
1402
1403         /* For some incomprehensible reason Oracle distributes
1404            libraries for Solaris in which some of the objects have
1405            bogus sh_link fields.  It would be nice if we could just
1406            reject them, but, unfortunately, some people need to use
1407            them.  We scan through the section headers; if we find only
1408            one suitable symbol table, we clobber the sh_link to point
1409            to it.  I hope this doesn't break anything.  */
1410         if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1411             && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1412           {
1413             int scan;
1414             int found;
1415
1416             found = 0;
1417             for (scan = 1; scan < ehdr->e_shnum; scan++)
1418               {
1419                 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1420                     || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1421                   {
1422                     if (found != 0)
1423                       {
1424                         found = 0;
1425                         break;
1426                       }
1427                     found = scan;
1428                   }
1429               }
1430             if (found != 0)
1431               hdr->sh_link = found;
1432           }
1433
1434         /* Get the symbol table.  */
1435         if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1436             && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1437           return false;
1438
1439         /* If this reloc section does not use the main symbol table we
1440            don't treat it as a reloc section.  BFD can't adequately
1441            represent such a section, so at least for now, we don't
1442            try.  We just present it as a normal section.  We also
1443            can't use it as a reloc section if it points to the null
1444            section.  */
1445         if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1446           return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1447
1448         if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1449           return false;
1450         target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1451         if (target_sect == NULL)
1452           return false;
1453
1454         if ((target_sect->flags & SEC_RELOC) == 0
1455             || target_sect->reloc_count == 0)
1456           hdr2 = &elf_section_data (target_sect)->rel_hdr;
1457         else
1458           {
1459             BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1460             hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
1461             elf_section_data (target_sect)->rel_hdr2 = hdr2;
1462           }
1463         *hdr2 = *hdr;
1464         elf_elfsections (abfd)[shindex] = hdr2;
1465         target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1466         target_sect->flags |= SEC_RELOC;
1467         target_sect->relocation = NULL;
1468         target_sect->rel_filepos = hdr->sh_offset;
1469         /* In the section to which the relocations apply, mark whether
1470            its relocations are of the REL or RELA variety.  */
1471         if (hdr->sh_size != 0)
1472           elf_section_data (target_sect)->use_rela_p
1473             = (hdr->sh_type == SHT_RELA);
1474         abfd->flags |= HAS_RELOC;
1475         return true;
1476       }
1477       break;
1478
1479     case SHT_GNU_verdef:
1480       elf_dynverdef (abfd) = shindex;
1481       elf_tdata (abfd)->dynverdef_hdr = *hdr;
1482       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1483       break;
1484
1485     case SHT_GNU_versym:
1486       elf_dynversym (abfd) = shindex;
1487       elf_tdata (abfd)->dynversym_hdr = *hdr;
1488       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1489       break;
1490
1491     case SHT_GNU_verneed:
1492       elf_dynverref (abfd) = shindex;
1493       elf_tdata (abfd)->dynverref_hdr = *hdr;
1494       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1495       break;
1496
1497     case SHT_SHLIB:
1498       return true;
1499
1500     default:
1501       /* Check for any processor-specific section types.  */
1502       {
1503         if (bed->elf_backend_section_from_shdr)
1504           (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1505       }
1506       break;
1507     }
1508
1509   return true;
1510 }
1511
1512 /* Given an ELF section number, retrieve the corresponding BFD
1513    section.  */
1514
1515 asection *
1516 bfd_section_from_elf_index (abfd, index)
1517      bfd *abfd;
1518      unsigned int index;
1519 {
1520   BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
1521   if (index >= elf_elfheader (abfd)->e_shnum)
1522     return NULL;
1523   return elf_elfsections (abfd)[index]->bfd_section;
1524 }
1525
1526 boolean
1527 _bfd_elf_new_section_hook (abfd, sec)
1528      bfd *abfd;
1529      asection *sec;
1530 {
1531   struct bfd_elf_section_data *sdata;
1532
1533   sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, sizeof (*sdata));
1534   if (!sdata)
1535     return false;
1536   sec->used_by_bfd = (PTR) sdata;
1537
1538   /* Indicate whether or not this section should use RELA relocations.  */
1539   sdata->use_rela_p
1540     = get_elf_backend_data (abfd)->default_use_rela_p;
1541
1542   return true;
1543 }
1544
1545 /* Create a new bfd section from an ELF program header.
1546
1547    Since program segments have no names, we generate a synthetic name
1548    of the form segment<NUM>, where NUM is generally the index in the
1549    program header table.  For segments that are split (see below) we
1550    generate the names segment<NUM>a and segment<NUM>b.
1551
1552    Note that some program segments may have a file size that is different than
1553    (less than) the memory size.  All this means is that at execution the
1554    system must allocate the amount of memory specified by the memory size,
1555    but only initialize it with the first "file size" bytes read from the
1556    file.  This would occur for example, with program segments consisting
1557    of combined data+bss.
1558
1559    To handle the above situation, this routine generates TWO bfd sections
1560    for the single program segment.  The first has the length specified by
1561    the file size of the segment, and the second has the length specified
1562    by the difference between the two sizes.  In effect, the segment is split
1563    into it's initialized and uninitialized parts.
1564
1565  */
1566
1567 boolean
1568 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
1569      bfd *abfd;
1570      Elf_Internal_Phdr *hdr;
1571      int index;
1572      const char *typename;
1573 {
1574   asection *newsect;
1575   char *name;
1576   char namebuf[64];
1577   int split;
1578
1579   split = ((hdr->p_memsz > 0)
1580             && (hdr->p_filesz > 0)
1581             && (hdr->p_memsz > hdr->p_filesz));
1582   sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
1583   name = bfd_alloc (abfd, strlen (namebuf) + 1);
1584   if (!name)
1585     return false;
1586   strcpy (name, namebuf);
1587   newsect = bfd_make_section (abfd, name);
1588   if (newsect == NULL)
1589     return false;
1590   newsect->vma = hdr->p_vaddr;
1591   newsect->lma = hdr->p_paddr;
1592   newsect->_raw_size = hdr->p_filesz;
1593   newsect->filepos = hdr->p_offset;
1594   newsect->flags |= SEC_HAS_CONTENTS;
1595   if (hdr->p_type == PT_LOAD)
1596     {
1597       newsect->flags |= SEC_ALLOC;
1598       newsect->flags |= SEC_LOAD;
1599       if (hdr->p_flags & PF_X)
1600         {
1601           /* FIXME: all we known is that it has execute PERMISSION,
1602              may be data.  */
1603           newsect->flags |= SEC_CODE;
1604         }
1605     }
1606   if (!(hdr->p_flags & PF_W))
1607     {
1608       newsect->flags |= SEC_READONLY;
1609     }
1610
1611   if (split)
1612     {
1613       sprintf (namebuf, "%s%db", typename, index);
1614       name = bfd_alloc (abfd, strlen (namebuf) + 1);
1615       if (!name)
1616         return false;
1617       strcpy (name, namebuf);
1618       newsect = bfd_make_section (abfd, name);
1619       if (newsect == NULL)
1620         return false;
1621       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
1622       newsect->lma = hdr->p_paddr + hdr->p_filesz;
1623       newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
1624       if (hdr->p_type == PT_LOAD)
1625         {
1626           newsect->flags |= SEC_ALLOC;
1627           if (hdr->p_flags & PF_X)
1628             newsect->flags |= SEC_CODE;
1629         }
1630       if (!(hdr->p_flags & PF_W))
1631         newsect->flags |= SEC_READONLY;
1632     }
1633
1634   return true;
1635 }
1636
1637 boolean
1638 bfd_section_from_phdr (abfd, hdr, index)
1639      bfd *abfd;
1640      Elf_Internal_Phdr *hdr;
1641      int index;
1642 {
1643   struct elf_backend_data *bed;
1644
1645   switch (hdr->p_type)
1646     {
1647     case PT_NULL:
1648       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
1649
1650     case PT_LOAD:
1651       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
1652
1653     case PT_DYNAMIC:
1654       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
1655
1656     case PT_INTERP:
1657       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
1658
1659     case PT_NOTE:
1660       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
1661         return false;
1662       if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
1663         return false;
1664       return true;
1665
1666     case PT_SHLIB:
1667       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
1668
1669     case PT_PHDR:
1670       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
1671
1672     default:
1673       /* Check for any processor-specific program segment types.
1674          If no handler for them, default to making "segment" sections.  */
1675       bed = get_elf_backend_data (abfd);
1676       if (bed->elf_backend_section_from_phdr)
1677         return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
1678       else
1679         return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
1680     }
1681 }
1682
1683 /* Initialize REL_HDR, the section-header for new section, containing
1684    relocations against ASECT.  If USE_RELA_P is true, we use RELA
1685    relocations; otherwise, we use REL relocations.  */
1686
1687 boolean
1688 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
1689      bfd *abfd;
1690      Elf_Internal_Shdr *rel_hdr;
1691      asection *asect;
1692      boolean use_rela_p;
1693 {
1694   char *name;
1695   struct elf_backend_data *bed;
1696
1697   bed = get_elf_backend_data (abfd);
1698   name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
1699   if (name == NULL)
1700     return false;
1701   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
1702   rel_hdr->sh_name =
1703     (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
1704                                        true, false);
1705   if (rel_hdr->sh_name == (unsigned int) -1)
1706     return false;
1707   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1708   rel_hdr->sh_entsize = (use_rela_p
1709                          ? bed->s->sizeof_rela
1710                          : bed->s->sizeof_rel);
1711   rel_hdr->sh_addralign = bed->s->file_align;
1712   rel_hdr->sh_flags = 0;
1713   rel_hdr->sh_addr = 0;
1714   rel_hdr->sh_size = 0;
1715   rel_hdr->sh_offset = 0;
1716
1717   return true;
1718 }
1719
1720 /* Set up an ELF internal section header for a section.  */
1721
1722 static void
1723 elf_fake_sections (abfd, asect, failedptrarg)
1724      bfd *abfd;
1725      asection *asect;
1726      PTR failedptrarg;
1727 {
1728   struct elf_backend_data *bed = get_elf_backend_data (abfd);
1729   boolean *failedptr = (boolean *) failedptrarg;
1730   Elf_Internal_Shdr *this_hdr;
1731
1732   if (*failedptr)
1733     {
1734       /* We already failed; just get out of the bfd_map_over_sections
1735          loop.  */
1736       return;
1737     }
1738
1739   this_hdr = &elf_section_data (asect)->this_hdr;
1740
1741   this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
1742                                                           asect->name,
1743                                                           true, false);
1744   if (this_hdr->sh_name == (unsigned long) -1)
1745     {
1746       *failedptr = true;
1747       return;
1748     }
1749
1750   this_hdr->sh_flags = 0;
1751
1752   if ((asect->flags & SEC_ALLOC) != 0
1753       || asect->user_set_vma)
1754     this_hdr->sh_addr = asect->vma;
1755   else
1756     this_hdr->sh_addr = 0;
1757
1758   this_hdr->sh_offset = 0;
1759   this_hdr->sh_size = asect->_raw_size;
1760   this_hdr->sh_link = 0;
1761   this_hdr->sh_addralign = 1 << asect->alignment_power;
1762   /* The sh_entsize and sh_info fields may have been set already by
1763      copy_private_section_data.  */
1764
1765   this_hdr->bfd_section = asect;
1766   this_hdr->contents = NULL;
1767
1768   /* FIXME: This should not be based on section names.  */
1769   if (strcmp (asect->name, ".dynstr") == 0)
1770     this_hdr->sh_type = SHT_STRTAB;
1771   else if (strcmp (asect->name, ".hash") == 0)
1772     {
1773       this_hdr->sh_type = SHT_HASH;
1774       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
1775     }
1776   else if (strcmp (asect->name, ".dynsym") == 0)
1777     {
1778       this_hdr->sh_type = SHT_DYNSYM;
1779       this_hdr->sh_entsize = bed->s->sizeof_sym;
1780     }
1781   else if (strcmp (asect->name, ".dynamic") == 0)
1782     {
1783       this_hdr->sh_type = SHT_DYNAMIC;
1784       this_hdr->sh_entsize = bed->s->sizeof_dyn;
1785     }
1786   else if (strncmp (asect->name, ".rela", 5) == 0
1787            && get_elf_backend_data (abfd)->may_use_rela_p)
1788     {
1789       this_hdr->sh_type = SHT_RELA;
1790       this_hdr->sh_entsize = bed->s->sizeof_rela;
1791     }
1792   else if (strncmp (asect->name, ".rel", 4) == 0
1793            && get_elf_backend_data (abfd)->may_use_rel_p)
1794     {
1795       this_hdr->sh_type = SHT_REL;
1796       this_hdr->sh_entsize = bed->s->sizeof_rel;
1797     }
1798   else if (strncmp (asect->name, ".note", 5) == 0)
1799     this_hdr->sh_type = SHT_NOTE;
1800   else if (strncmp (asect->name, ".stab", 5) == 0
1801            && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
1802     this_hdr->sh_type = SHT_STRTAB;
1803   else if (strcmp (asect->name, ".gnu.version") == 0)
1804     {
1805       this_hdr->sh_type = SHT_GNU_versym;
1806       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
1807     }
1808   else if (strcmp (asect->name, ".gnu.version_d") == 0)
1809     {
1810       this_hdr->sh_type = SHT_GNU_verdef;
1811       this_hdr->sh_entsize = 0;
1812       /* objcopy or strip will copy over sh_info, but may not set
1813          cverdefs.  The linker will set cverdefs, but sh_info will be
1814          zero.  */
1815       if (this_hdr->sh_info == 0)
1816         this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
1817       else
1818         BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
1819                     || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
1820     }
1821   else if (strcmp (asect->name, ".gnu.version_r") == 0)
1822     {
1823       this_hdr->sh_type = SHT_GNU_verneed;
1824       this_hdr->sh_entsize = 0;
1825       /* objcopy or strip will copy over sh_info, but may not set
1826          cverrefs.  The linker will set cverrefs, but sh_info will be
1827          zero.  */
1828       if (this_hdr->sh_info == 0)
1829         this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
1830       else
1831         BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
1832                     || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
1833     }
1834   else if ((asect->flags & SEC_ALLOC) != 0
1835            && ((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0))
1836     this_hdr->sh_type = SHT_NOBITS;
1837   else
1838     this_hdr->sh_type = SHT_PROGBITS;
1839
1840   if ((asect->flags & SEC_ALLOC) != 0)
1841     this_hdr->sh_flags |= SHF_ALLOC;
1842   if ((asect->flags & SEC_READONLY) == 0)
1843     this_hdr->sh_flags |= SHF_WRITE;
1844   if ((asect->flags & SEC_CODE) != 0)
1845     this_hdr->sh_flags |= SHF_EXECINSTR;
1846   if ((asect->flags & SEC_MERGE) != 0)
1847     {
1848       this_hdr->sh_flags |= SHF_MERGE;
1849       this_hdr->sh_entsize = asect->entsize;
1850       if ((asect->flags & SEC_STRINGS) != 0)
1851         this_hdr->sh_flags |= SHF_STRINGS;
1852     }
1853
1854   /* Check for processor-specific section types.  */
1855   if (bed->elf_backend_fake_sections)
1856     (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1857
1858   /* If the section has relocs, set up a section header for the
1859      SHT_REL[A] section.  If two relocation sections are required for
1860      this section, it is up to the processor-specific back-end to
1861      create the other.  */
1862   if ((asect->flags & SEC_RELOC) != 0
1863       && !_bfd_elf_init_reloc_shdr (abfd,
1864                                     &elf_section_data (asect)->rel_hdr,
1865                                     asect,
1866                                     elf_section_data (asect)->use_rela_p))
1867     *failedptr = true;
1868 }
1869
1870 /* Assign all ELF section numbers.  The dummy first section is handled here
1871    too.  The link/info pointers for the standard section types are filled
1872    in here too, while we're at it.  */
1873
1874 static boolean
1875 assign_section_numbers (abfd)
1876      bfd *abfd;
1877 {
1878   struct elf_obj_tdata *t = elf_tdata (abfd);
1879   asection *sec;
1880   unsigned int section_number;
1881   Elf_Internal_Shdr **i_shdrp;
1882
1883   section_number = 1;
1884
1885   for (sec = abfd->sections; sec; sec = sec->next)
1886     {
1887       struct bfd_elf_section_data *d = elf_section_data (sec);
1888
1889       d->this_idx = section_number++;
1890       if ((sec->flags & SEC_RELOC) == 0)
1891         d->rel_idx = 0;
1892       else
1893         d->rel_idx = section_number++;
1894
1895       if (d->rel_hdr2)
1896         d->rel_idx2 = section_number++;
1897       else
1898         d->rel_idx2 = 0;
1899     }
1900
1901   t->shstrtab_section = section_number++;
1902   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
1903   t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1904
1905   if (bfd_get_symcount (abfd) > 0)
1906     {
1907       t->symtab_section = section_number++;
1908       t->strtab_section = section_number++;
1909     }
1910
1911   elf_elfheader (abfd)->e_shnum = section_number;
1912
1913   /* Set up the list of section header pointers, in agreement with the
1914      indices.  */
1915   i_shdrp = ((Elf_Internal_Shdr **)
1916              bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
1917   if (i_shdrp == NULL)
1918     return false;
1919
1920   i_shdrp[0] = ((Elf_Internal_Shdr *)
1921                 bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
1922   if (i_shdrp[0] == NULL)
1923     {
1924       bfd_release (abfd, i_shdrp);
1925       return false;
1926     }
1927   memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
1928
1929   elf_elfsections (abfd) = i_shdrp;
1930
1931   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1932   if (bfd_get_symcount (abfd) > 0)
1933     {
1934       i_shdrp[t->symtab_section] = &t->symtab_hdr;
1935       i_shdrp[t->strtab_section] = &t->strtab_hdr;
1936       t->symtab_hdr.sh_link = t->strtab_section;
1937     }
1938   for (sec = abfd->sections; sec; sec = sec->next)
1939     {
1940       struct bfd_elf_section_data *d = elf_section_data (sec);
1941       asection *s;
1942       const char *name;
1943
1944       i_shdrp[d->this_idx] = &d->this_hdr;
1945       if (d->rel_idx != 0)
1946         i_shdrp[d->rel_idx] = &d->rel_hdr;
1947       if (d->rel_idx2 != 0)
1948         i_shdrp[d->rel_idx2] = d->rel_hdr2;
1949
1950       /* Fill in the sh_link and sh_info fields while we're at it.  */
1951
1952       /* sh_link of a reloc section is the section index of the symbol
1953          table.  sh_info is the section index of the section to which
1954          the relocation entries apply.  */
1955       if (d->rel_idx != 0)
1956         {
1957           d->rel_hdr.sh_link = t->symtab_section;
1958           d->rel_hdr.sh_info = d->this_idx;
1959         }
1960       if (d->rel_idx2 != 0)
1961         {
1962           d->rel_hdr2->sh_link = t->symtab_section;
1963           d->rel_hdr2->sh_info = d->this_idx;
1964         }
1965
1966       switch (d->this_hdr.sh_type)
1967         {
1968         case SHT_REL:
1969         case SHT_RELA:
1970           /* A reloc section which we are treating as a normal BFD
1971              section.  sh_link is the section index of the symbol
1972              table.  sh_info is the section index of the section to
1973              which the relocation entries apply.  We assume that an
1974              allocated reloc section uses the dynamic symbol table.
1975              FIXME: How can we be sure?  */
1976           s = bfd_get_section_by_name (abfd, ".dynsym");
1977           if (s != NULL)
1978             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1979
1980           /* We look up the section the relocs apply to by name.  */
1981           name = sec->name;
1982           if (d->this_hdr.sh_type == SHT_REL)
1983             name += 4;
1984           else
1985             name += 5;
1986           s = bfd_get_section_by_name (abfd, name);
1987           if (s != NULL)
1988             d->this_hdr.sh_info = elf_section_data (s)->this_idx;
1989           break;
1990
1991         case SHT_STRTAB:
1992           /* We assume that a section named .stab*str is a stabs
1993              string section.  We look for a section with the same name
1994              but without the trailing ``str'', and set its sh_link
1995              field to point to this section.  */
1996           if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
1997               && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
1998             {
1999               size_t len;
2000               char *alc;
2001
2002               len = strlen (sec->name);
2003               alc = (char *) bfd_malloc (len - 2);
2004               if (alc == NULL)
2005                 return false;
2006               strncpy (alc, sec->name, len - 3);
2007               alc[len - 3] = '\0';
2008               s = bfd_get_section_by_name (abfd, alc);
2009               free (alc);
2010               if (s != NULL)
2011                 {
2012                   elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2013
2014                   /* This is a .stab section.  */
2015                   elf_section_data (s)->this_hdr.sh_entsize =
2016                     4 + 2 * bfd_get_arch_size (abfd) / 8;
2017                 }
2018             }
2019           break;
2020
2021         case SHT_DYNAMIC:
2022         case SHT_DYNSYM:
2023         case SHT_GNU_verneed:
2024         case SHT_GNU_verdef:
2025           /* sh_link is the section header index of the string table
2026              used for the dynamic entries, or the symbol table, or the
2027              version strings.  */
2028           s = bfd_get_section_by_name (abfd, ".dynstr");
2029           if (s != NULL)
2030             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2031           break;
2032
2033         case SHT_HASH:
2034         case SHT_GNU_versym:
2035           /* sh_link is the section header index of the symbol table
2036              this hash table or version table is for.  */
2037           s = bfd_get_section_by_name (abfd, ".dynsym");
2038           if (s != NULL)
2039             d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2040           break;
2041         }
2042     }
2043
2044   return true;
2045 }
2046
2047 /* Map symbol from it's internal number to the external number, moving
2048    all local symbols to be at the head of the list.  */
2049
2050 static INLINE int
2051 sym_is_global (abfd, sym)
2052      bfd *abfd;
2053      asymbol *sym;
2054 {
2055   /* If the backend has a special mapping, use it.  */
2056   if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2057     return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2058             (abfd, sym));
2059
2060   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2061           || bfd_is_und_section (bfd_get_section (sym))
2062           || bfd_is_com_section (bfd_get_section (sym)));
2063 }
2064
2065 static boolean
2066 elf_map_symbols (abfd)
2067      bfd *abfd;
2068 {
2069   int symcount = bfd_get_symcount (abfd);
2070   asymbol **syms = bfd_get_outsymbols (abfd);
2071   asymbol **sect_syms;
2072   int num_locals = 0;
2073   int num_globals = 0;
2074   int num_locals2 = 0;
2075   int num_globals2 = 0;
2076   int max_index = 0;
2077   int num_sections = 0;
2078   int idx;
2079   asection *asect;
2080   asymbol **new_syms;
2081   asymbol *sym;
2082
2083 #ifdef DEBUG
2084   fprintf (stderr, "elf_map_symbols\n");
2085   fflush (stderr);
2086 #endif
2087
2088   /* Add a section symbol for each BFD section.  FIXME: Is this really
2089      necessary?  */
2090   for (asect = abfd->sections; asect; asect = asect->next)
2091     {
2092       if (max_index < asect->index)
2093         max_index = asect->index;
2094     }
2095
2096   max_index++;
2097   sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
2098   if (sect_syms == NULL)
2099     return false;
2100   elf_section_syms (abfd) = sect_syms;
2101   elf_num_section_syms (abfd) = max_index;
2102
2103   for (idx = 0; idx < symcount; idx++)
2104     {
2105       sym = syms[idx];
2106
2107       if ((sym->flags & BSF_SECTION_SYM) != 0
2108           && sym->value == 0)
2109         {
2110           asection *sec;
2111
2112           sec = sym->section;
2113
2114           if (sec->owner != NULL)
2115             {
2116               if (sec->owner != abfd)
2117                 {
2118                   if (sec->output_offset != 0)
2119                     continue;
2120
2121                   sec = sec->output_section;
2122
2123                   /* Empty sections in the input files may have had a section
2124                      symbol created for them.  (See the comment near the end of
2125                      _bfd_generic_link_output_symbols in linker.c).  If the linker
2126                      script discards such sections then we will reach this point.
2127                      Since we know that we cannot avoid this case, we detect it
2128                      and skip the abort and the assignment to the sect_syms array.
2129                      To reproduce this particular case try running the linker
2130                      testsuite test ld-scripts/weak.exp for an ELF port that uses
2131                      the generic linker.  */
2132                   if (sec->owner == NULL)
2133                     continue;
2134
2135                   BFD_ASSERT (sec->owner == abfd);
2136                 }
2137               sect_syms[sec->index] = syms[idx];
2138             }
2139         }
2140     }
2141
2142   for (asect = abfd->sections; asect; asect = asect->next)
2143     {
2144       if (sect_syms[asect->index] != NULL)
2145         continue;
2146
2147       sym = bfd_make_empty_symbol (abfd);
2148       if (sym == NULL)
2149         return false;
2150       sym->the_bfd = abfd;
2151       sym->name = asect->name;
2152       sym->value = 0;
2153       /* Set the flags to 0 to indicate that this one was newly added.  */
2154       sym->flags = 0;
2155       sym->section = asect;
2156       sect_syms[asect->index] = sym;
2157       num_sections++;
2158 #ifdef DEBUG
2159       fprintf (stderr,
2160  _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
2161                asect->name, (long) asect->vma, asect->index, (long) asect);
2162 #endif
2163     }
2164
2165   /* Classify all of the symbols.  */
2166   for (idx = 0; idx < symcount; idx++)
2167     {
2168       if (!sym_is_global (abfd, syms[idx]))
2169         num_locals++;
2170       else
2171         num_globals++;
2172     }
2173   for (asect = abfd->sections; asect; asect = asect->next)
2174     {
2175       if (sect_syms[asect->index] != NULL
2176           && sect_syms[asect->index]->flags == 0)
2177         {
2178           sect_syms[asect->index]->flags = BSF_SECTION_SYM;
2179           if (!sym_is_global (abfd, sect_syms[asect->index]))
2180             num_locals++;
2181           else
2182             num_globals++;
2183           sect_syms[asect->index]->flags = 0;
2184         }
2185     }
2186
2187   /* Now sort the symbols so the local symbols are first.  */
2188   new_syms = ((asymbol **)
2189               bfd_alloc (abfd,
2190                          (num_locals + num_globals) * sizeof (asymbol *)));
2191   if (new_syms == NULL)
2192     return false;
2193
2194   for (idx = 0; idx < symcount; idx++)
2195     {
2196       asymbol *sym = syms[idx];
2197       int i;
2198
2199       if (!sym_is_global (abfd, sym))
2200         i = num_locals2++;
2201       else
2202         i = num_locals + num_globals2++;
2203       new_syms[i] = sym;
2204       sym->udata.i = i + 1;
2205     }
2206   for (asect = abfd->sections; asect; asect = asect->next)
2207     {
2208       if (sect_syms[asect->index] != NULL
2209           && sect_syms[asect->index]->flags == 0)
2210         {
2211           asymbol *sym = sect_syms[asect->index];
2212           int i;
2213
2214           sym->flags = BSF_SECTION_SYM;
2215           if (!sym_is_global (abfd, sym))
2216             i = num_locals2++;
2217           else
2218             i = num_locals + num_globals2++;
2219           new_syms[i] = sym;
2220           sym->udata.i = i + 1;
2221         }
2222     }
2223
2224   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
2225
2226   elf_num_locals (abfd) = num_locals;
2227   elf_num_globals (abfd) = num_globals;
2228   return true;
2229 }
2230
2231 /* Align to the maximum file alignment that could be required for any
2232    ELF data structure.  */
2233
2234 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
2235 static INLINE file_ptr
2236 align_file_position (off, align)
2237      file_ptr off;
2238      int align;
2239 {
2240   return (off + align - 1) & ~(align - 1);
2241 }
2242
2243 /* Assign a file position to a section, optionally aligning to the
2244    required section alignment.  */
2245
2246 INLINE file_ptr
2247 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
2248      Elf_Internal_Shdr *i_shdrp;
2249      file_ptr offset;
2250      boolean align;
2251 {
2252   if (align)
2253     {
2254       unsigned int al;
2255
2256       al = i_shdrp->sh_addralign;
2257       if (al > 1)
2258         offset = BFD_ALIGN (offset, al);
2259     }
2260   i_shdrp->sh_offset = offset;
2261   if (i_shdrp->bfd_section != NULL)
2262     i_shdrp->bfd_section->filepos = offset;
2263   if (i_shdrp->sh_type != SHT_NOBITS)
2264     offset += i_shdrp->sh_size;
2265   return offset;
2266 }
2267
2268 /* Compute the file positions we are going to put the sections at, and
2269    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
2270    is not NULL, this is being called by the ELF backend linker.  */
2271
2272 boolean
2273 _bfd_elf_compute_section_file_positions (abfd, link_info)
2274      bfd *abfd;
2275      struct bfd_link_info *link_info;
2276 {
2277   struct elf_backend_data *bed = get_elf_backend_data (abfd);
2278   boolean failed;
2279   struct bfd_strtab_hash *strtab;
2280   Elf_Internal_Shdr *shstrtab_hdr;
2281
2282   if (abfd->output_has_begun)
2283     return true;
2284
2285   /* Do any elf backend specific processing first.  */
2286   if (bed->elf_backend_begin_write_processing)
2287     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
2288
2289   if (! prep_headers (abfd))
2290     return false;
2291
2292   /* Post process the headers if necessary.  */
2293   if (bed->elf_backend_post_process_headers)
2294     (*bed->elf_backend_post_process_headers) (abfd, link_info);
2295
2296   failed = false;
2297   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
2298   if (failed)
2299     return false;
2300
2301   if (!assign_section_numbers (abfd))
2302     return false;
2303
2304   /* The backend linker builds symbol table information itself.  */
2305   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2306     {
2307       /* Non-zero if doing a relocatable link.  */
2308       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
2309
2310       if (! swap_out_syms (abfd, &strtab, relocatable_p))
2311         return false;
2312     }
2313
2314   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
2315   /* sh_name was set in prep_headers.  */
2316   shstrtab_hdr->sh_type = SHT_STRTAB;
2317   shstrtab_hdr->sh_flags = 0;
2318   shstrtab_hdr->sh_addr = 0;
2319   shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
2320   shstrtab_hdr->sh_entsize = 0;
2321   shstrtab_hdr->sh_link = 0;
2322   shstrtab_hdr->sh_info = 0;
2323   /* sh_offset is set in assign_file_positions_except_relocs.  */
2324   shstrtab_hdr->sh_addralign = 1;
2325
2326   if (!assign_file_positions_except_relocs (abfd))
2327     return false;
2328
2329   if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2330     {
2331       file_ptr off;
2332       Elf_Internal_Shdr *hdr;
2333
2334       off = elf_tdata (abfd)->next_file_pos;
2335
2336       hdr = &elf_tdata (abfd)->symtab_hdr;
2337       off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2338
2339       hdr = &elf_tdata (abfd)->strtab_hdr;
2340       off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2341
2342       elf_tdata (abfd)->next_file_pos = off;
2343
2344       /* Now that we know where the .strtab section goes, write it
2345          out.  */
2346       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
2347           || ! _bfd_stringtab_emit (abfd, strtab))
2348         return false;
2349       _bfd_stringtab_free (strtab);
2350     }
2351
2352   abfd->output_has_begun = true;
2353
2354   return true;
2355 }
2356
2357 /* Create a mapping from a set of sections to a program segment.  */
2358
2359 static INLINE struct elf_segment_map *
2360 make_mapping (abfd, sections, from, to, phdr)
2361      bfd *abfd;
2362      asection **sections;
2363      unsigned int from;
2364      unsigned int to;
2365      boolean phdr;
2366 {
2367   struct elf_segment_map *m;
2368   unsigned int i;
2369   asection **hdrpp;
2370
2371   m = ((struct elf_segment_map *)
2372        bfd_zalloc (abfd,
2373                    (sizeof (struct elf_segment_map)
2374                     + (to - from - 1) * sizeof (asection *))));
2375   if (m == NULL)
2376     return NULL;
2377   m->next = NULL;
2378   m->p_type = PT_LOAD;
2379   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
2380     m->sections[i - from] = *hdrpp;
2381   m->count = to - from;
2382
2383   if (from == 0 && phdr)
2384     {
2385       /* Include the headers in the first PT_LOAD segment.  */
2386       m->includes_filehdr = 1;
2387       m->includes_phdrs = 1;
2388     }
2389
2390   return m;
2391 }
2392
2393 /* Set up a mapping from BFD sections to program segments.  */
2394
2395 static boolean
2396 map_sections_to_segments (abfd)
2397      bfd *abfd;
2398 {
2399   asection **sections = NULL;
2400   asection *s;
2401   unsigned int i;
2402   unsigned int count;
2403   struct elf_segment_map *mfirst;
2404   struct elf_segment_map **pm;
2405   struct elf_segment_map *m;
2406   asection *last_hdr;
2407   unsigned int phdr_index;
2408   bfd_vma maxpagesize;
2409   asection **hdrpp;
2410   boolean phdr_in_segment = true;
2411   boolean writable;
2412   asection *dynsec;
2413
2414   if (elf_tdata (abfd)->segment_map != NULL)
2415     return true;
2416
2417   if (bfd_count_sections (abfd) == 0)
2418     return true;
2419
2420   /* Select the allocated sections, and sort them.  */
2421
2422   sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
2423                                        * sizeof (asection *));
2424   if (sections == NULL)
2425     goto error_return;
2426
2427   i = 0;
2428   for (s = abfd->sections; s != NULL; s = s->next)
2429     {
2430       if ((s->flags & SEC_ALLOC) != 0)
2431         {
2432           sections[i] = s;
2433           ++i;
2434         }
2435     }
2436   BFD_ASSERT (i <= bfd_count_sections (abfd));
2437   count = i;
2438
2439   qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
2440
2441   /* Build the mapping.  */
2442
2443   mfirst = NULL;
2444   pm = &mfirst;
2445
2446   /* If we have a .interp section, then create a PT_PHDR segment for
2447      the program headers and a PT_INTERP segment for the .interp
2448      section.  */
2449   s = bfd_get_section_by_name (abfd, ".interp");
2450   if (s != NULL && (s->flags & SEC_LOAD) != 0)
2451     {
2452       m = ((struct elf_segment_map *)
2453            bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2454       if (m == NULL)
2455         goto error_return;
2456       m->next = NULL;
2457       m->p_type = PT_PHDR;
2458       /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
2459       m->p_flags = PF_R | PF_X;
2460       m->p_flags_valid = 1;
2461       m->includes_phdrs = 1;
2462
2463       *pm = m;
2464       pm = &m->next;
2465
2466       m = ((struct elf_segment_map *)
2467            bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2468       if (m == NULL)
2469         goto error_return;
2470       m->next = NULL;
2471       m->p_type = PT_INTERP;
2472       m->count = 1;
2473       m->sections[0] = s;
2474
2475       *pm = m;
2476       pm = &m->next;
2477     }
2478
2479   /* Look through the sections.  We put sections in the same program
2480      segment when the start of the second section can be placed within
2481      a few bytes of the end of the first section.  */
2482   last_hdr = NULL;
2483   phdr_index = 0;
2484   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2485   writable = false;
2486   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
2487   if (dynsec != NULL
2488       && (dynsec->flags & SEC_LOAD) == 0)
2489     dynsec = NULL;
2490
2491   /* Deal with -Ttext or something similar such that the first section
2492      is not adjacent to the program headers.  This is an
2493      approximation, since at this point we don't know exactly how many
2494      program headers we will need.  */
2495   if (count > 0)
2496     {
2497       bfd_size_type phdr_size;
2498
2499       phdr_size = elf_tdata (abfd)->program_header_size;
2500       if (phdr_size == 0)
2501         phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
2502       if ((abfd->flags & D_PAGED) == 0
2503           || sections[0]->lma < phdr_size
2504           || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
2505         phdr_in_segment = false;
2506     }
2507
2508   for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
2509     {
2510       asection *hdr;
2511       boolean new_segment;
2512
2513       hdr = *hdrpp;
2514
2515       /* See if this section and the last one will fit in the same
2516          segment.  */
2517
2518       if (last_hdr == NULL)
2519         {
2520           /* If we don't have a segment yet, then we don't need a new
2521              one (we build the last one after this loop).  */
2522           new_segment = false;
2523         }
2524       else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
2525         {
2526           /* If this section has a different relation between the
2527              virtual address and the load address, then we need a new
2528              segment.  */
2529           new_segment = true;
2530         }
2531       else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2532                < BFD_ALIGN (hdr->lma, maxpagesize))
2533         {
2534           /* If putting this section in this segment would force us to
2535              skip a page in the segment, then we need a new segment.  */
2536           new_segment = true;
2537         }
2538       else if ((last_hdr->flags & SEC_LOAD) == 0
2539                && (hdr->flags & SEC_LOAD) != 0)
2540         {
2541           /* We don't want to put a loadable section after a
2542              nonloadable section in the same segment.  */
2543           new_segment = true;
2544         }
2545       else if ((abfd->flags & D_PAGED) == 0)
2546         {
2547           /* If the file is not demand paged, which means that we
2548              don't require the sections to be correctly aligned in the
2549              file, then there is no other reason for a new segment.  */
2550           new_segment = false;
2551         }
2552       else if (! writable
2553                && (hdr->flags & SEC_READONLY) == 0
2554                && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2555                    == hdr->lma))
2556         {
2557           /* We don't want to put a writable section in a read only
2558              segment, unless they are on the same page in memory
2559              anyhow.  We already know that the last section does not
2560              bring us past the current section on the page, so the
2561              only case in which the new section is not on the same
2562              page as the previous section is when the previous section
2563              ends precisely on a page boundary.  */
2564           new_segment = true;
2565         }
2566       else
2567         {
2568           /* Otherwise, we can use the same segment.  */
2569           new_segment = false;
2570         }
2571
2572       if (! new_segment)
2573         {
2574           if ((hdr->flags & SEC_READONLY) == 0)
2575             writable = true;
2576           last_hdr = hdr;
2577           continue;
2578         }
2579
2580       /* We need a new program segment.  We must create a new program
2581          header holding all the sections from phdr_index until hdr.  */
2582
2583       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2584       if (m == NULL)
2585         goto error_return;
2586
2587       *pm = m;
2588       pm = &m->next;
2589
2590       if ((hdr->flags & SEC_READONLY) == 0)
2591         writable = true;
2592       else
2593         writable = false;
2594
2595       last_hdr = hdr;
2596       phdr_index = i;
2597       phdr_in_segment = false;
2598     }
2599
2600   /* Create a final PT_LOAD program segment.  */
2601   if (last_hdr != NULL)
2602     {
2603       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2604       if (m == NULL)
2605         goto error_return;
2606
2607       *pm = m;
2608       pm = &m->next;
2609     }
2610
2611   /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
2612   if (dynsec != NULL)
2613     {
2614       m = ((struct elf_segment_map *)
2615            bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2616       if (m == NULL)
2617         goto error_return;
2618       m->next = NULL;
2619       m->p_type = PT_DYNAMIC;
2620       m->count = 1;
2621       m->sections[0] = dynsec;
2622
2623       *pm = m;
2624       pm = &m->next;
2625     }
2626
2627   /* For each loadable .note section, add a PT_NOTE segment.  We don't
2628      use bfd_get_section_by_name, because if we link together
2629      nonloadable .note sections and loadable .note sections, we will
2630      generate two .note sections in the output file.  FIXME: Using
2631      names for section types is bogus anyhow.  */
2632   for (s = abfd->sections; s != NULL; s = s->next)
2633     {
2634       if ((s->flags & SEC_LOAD) != 0
2635           && strncmp (s->name, ".note", 5) == 0)
2636         {
2637           m = ((struct elf_segment_map *)
2638                bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2639           if (m == NULL)
2640             goto error_return;
2641           m->next = NULL;
2642           m->p_type = PT_NOTE;
2643           m->count = 1;
2644           m->sections[0] = s;
2645
2646           *pm = m;
2647           pm = &m->next;
2648         }
2649     }
2650
2651   free (sections);
2652   sections = NULL;
2653
2654   elf_tdata (abfd)->segment_map = mfirst;
2655   return true;
2656
2657  error_return:
2658   if (sections != NULL)
2659     free (sections);
2660   return false;
2661 }
2662
2663 /* Sort sections by address.  */
2664
2665 static int
2666 elf_sort_sections (arg1, arg2)
2667      const PTR arg1;
2668      const PTR arg2;
2669 {
2670   const asection *sec1 = *(const asection **) arg1;
2671   const asection *sec2 = *(const asection **) arg2;
2672
2673   /* Sort by LMA first, since this is the address used to
2674      place the section into a segment.  */
2675   if (sec1->lma < sec2->lma)
2676     return -1;
2677   else if (sec1->lma > sec2->lma)
2678     return 1;
2679
2680   /* Then sort by VMA.  Normally the LMA and the VMA will be
2681      the same, and this will do nothing.  */
2682   if (sec1->vma < sec2->vma)
2683     return -1;
2684   else if (sec1->vma > sec2->vma)
2685     return 1;
2686
2687   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
2688
2689 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2690
2691   if (TOEND (sec1))
2692     {
2693       if (TOEND (sec2))
2694         {
2695           /* If the indicies are the same, do not return 0
2696              here, but continue to try the next comparison.  */
2697           if (sec1->target_index - sec2->target_index != 0)
2698             return sec1->target_index - sec2->target_index;
2699         }
2700       else
2701         return 1;
2702     }
2703   else if (TOEND (sec2))
2704     return -1;
2705
2706 #undef TOEND
2707
2708   /* Sort by size, to put zero sized sections
2709      before others at the same address.  */
2710
2711   if (sec1->_raw_size < sec2->_raw_size)
2712     return -1;
2713   if (sec1->_raw_size > sec2->_raw_size)
2714     return 1;
2715
2716   return sec1->target_index - sec2->target_index;
2717 }
2718
2719 /* Assign file positions to the sections based on the mapping from
2720    sections to segments.  This function also sets up some fields in
2721    the file header, and writes out the program headers.  */
2722
2723 static boolean
2724 assign_file_positions_for_segments (abfd)
2725      bfd *abfd;
2726 {
2727   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2728   unsigned int count;
2729   struct elf_segment_map *m;
2730   unsigned int alloc;
2731   Elf_Internal_Phdr *phdrs;
2732   file_ptr off, voff;
2733   bfd_vma filehdr_vaddr, filehdr_paddr;
2734   bfd_vma phdrs_vaddr, phdrs_paddr;
2735   Elf_Internal_Phdr *p;
2736
2737   if (elf_tdata (abfd)->segment_map == NULL)
2738     {
2739       if (! map_sections_to_segments (abfd))
2740         return false;
2741     }
2742
2743   if (bed->elf_backend_modify_segment_map)
2744     {
2745       if (! (*bed->elf_backend_modify_segment_map) (abfd))
2746         return false;
2747     }
2748
2749   count = 0;
2750   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2751     ++count;
2752
2753   elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
2754   elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
2755   elf_elfheader (abfd)->e_phnum = count;
2756
2757   if (count == 0)
2758     return true;
2759
2760   /* If we already counted the number of program segments, make sure
2761      that we allocated enough space.  This happens when SIZEOF_HEADERS
2762      is used in a linker script.  */
2763   alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
2764   if (alloc != 0 && count > alloc)
2765     {
2766       ((*_bfd_error_handler)
2767        (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2768         bfd_get_filename (abfd), alloc, count));
2769       bfd_set_error (bfd_error_bad_value);
2770       return false;
2771     }
2772
2773   if (alloc == 0)
2774     alloc = count;
2775
2776   phdrs = ((Elf_Internal_Phdr *)
2777            bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr)));
2778   if (phdrs == NULL)
2779     return false;
2780
2781   off = bed->s->sizeof_ehdr;
2782   off += alloc * bed->s->sizeof_phdr;
2783
2784   filehdr_vaddr = 0;
2785   filehdr_paddr = 0;
2786   phdrs_vaddr = 0;
2787   phdrs_paddr = 0;
2788
2789   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2790        m != NULL;
2791        m = m->next, p++)
2792     {
2793       unsigned int i;
2794       asection **secpp;
2795
2796       /* If elf_segment_map is not from map_sections_to_segments, the
2797          sections may not be correctly ordered.  */
2798       if (m->count > 0)
2799         qsort (m->sections, (size_t) m->count, sizeof (asection *),
2800                elf_sort_sections);
2801
2802       p->p_type = m->p_type;
2803       p->p_flags = m->p_flags;
2804
2805       if (p->p_type == PT_LOAD
2806           && m->count > 0
2807           && (m->sections[0]->flags & SEC_ALLOC) != 0)
2808         {
2809           if ((abfd->flags & D_PAGED) != 0)
2810             off += (m->sections[0]->vma - off) % bed->maxpagesize;
2811           else
2812             {
2813               bfd_size_type align;
2814
2815               align = 0;
2816               for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2817                 {
2818                   bfd_size_type secalign;
2819
2820                   secalign = bfd_get_section_alignment (abfd, *secpp);
2821                   if (secalign > align)
2822                     align = secalign;
2823                 }
2824
2825               off += (m->sections[0]->vma - off) % (1 << align);
2826             }
2827         }
2828
2829       if (m->count == 0)
2830         p->p_vaddr = 0;
2831       else
2832         p->p_vaddr = m->sections[0]->vma;
2833
2834       if (m->p_paddr_valid)
2835         p->p_paddr = m->p_paddr;
2836       else if (m->count == 0)
2837         p->p_paddr = 0;
2838       else
2839         p->p_paddr = m->sections[0]->lma;
2840
2841       if (p->p_type == PT_LOAD
2842           && (abfd->flags & D_PAGED) != 0)
2843         p->p_align = bed->maxpagesize;
2844       else if (m->count == 0)
2845         p->p_align = bed->s->file_align;
2846       else
2847         p->p_align = 0;
2848
2849       p->p_offset = 0;
2850       p->p_filesz = 0;
2851       p->p_memsz = 0;
2852
2853       if (m->includes_filehdr)
2854         {
2855           if (! m->p_flags_valid)
2856             p->p_flags |= PF_R;
2857           p->p_offset = 0;
2858           p->p_filesz = bed->s->sizeof_ehdr;
2859           p->p_memsz = bed->s->sizeof_ehdr;
2860           if (m->count > 0)
2861             {
2862               BFD_ASSERT (p->p_type == PT_LOAD);
2863
2864               if (p->p_vaddr < (bfd_vma) off)
2865                 {
2866                   _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2867                                       bfd_get_filename (abfd));
2868                   bfd_set_error (bfd_error_bad_value);
2869                   return false;
2870                 }
2871
2872               p->p_vaddr -= off;
2873               if (! m->p_paddr_valid)
2874                 p->p_paddr -= off;
2875             }
2876           if (p->p_type == PT_LOAD)
2877             {
2878               filehdr_vaddr = p->p_vaddr;
2879               filehdr_paddr = p->p_paddr;
2880             }
2881         }
2882
2883       if (m->includes_phdrs)
2884         {
2885           if (! m->p_flags_valid)
2886             p->p_flags |= PF_R;
2887
2888           if (m->includes_filehdr)
2889             {
2890               if (p->p_type == PT_LOAD)
2891                 {
2892                   phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
2893                   phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
2894                 }
2895             }
2896           else
2897             {
2898               p->p_offset = bed->s->sizeof_ehdr;
2899
2900               if (m->count > 0)
2901                 {
2902                   BFD_ASSERT (p->p_type == PT_LOAD);
2903                   p->p_vaddr -= off - p->p_offset;
2904                   if (! m->p_paddr_valid)
2905                     p->p_paddr -= off - p->p_offset;
2906                 }
2907
2908               if (p->p_type == PT_LOAD)
2909                 {
2910                   phdrs_vaddr = p->p_vaddr;
2911                   phdrs_paddr = p->p_paddr;
2912                 }
2913               else
2914                 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
2915             }
2916
2917           p->p_filesz += alloc * bed->s->sizeof_phdr;
2918           p->p_memsz += alloc * bed->s->sizeof_phdr;
2919         }
2920
2921       if (p->p_type == PT_LOAD
2922           || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
2923         {
2924           if (! m->includes_filehdr && ! m->includes_phdrs)
2925             p->p_offset = off;
2926           else
2927             {
2928               file_ptr adjust;
2929
2930               adjust = off - (p->p_offset + p->p_filesz);
2931               p->p_filesz += adjust;
2932               p->p_memsz += adjust;
2933             }
2934         }
2935
2936       voff = off;
2937
2938       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2939         {
2940           asection *sec;
2941           flagword flags;
2942           bfd_size_type align;
2943
2944           sec = *secpp;
2945           flags = sec->flags;
2946           align = 1 << bfd_get_section_alignment (abfd, sec);
2947
2948           /* The section may have artificial alignment forced by a
2949              link script.  Notice this case by the gap between the
2950              cumulative phdr vma and the section's vma.  */
2951           if (p->p_vaddr + p->p_memsz < sec->vma)
2952             {
2953               bfd_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
2954
2955               p->p_memsz += adjust;
2956               off += adjust;
2957               voff += adjust;
2958               if ((flags & SEC_LOAD) != 0)
2959                 p->p_filesz += adjust;
2960             }
2961
2962           if (p->p_type == PT_LOAD)
2963             {
2964               bfd_signed_vma adjust;
2965
2966               if ((flags & SEC_LOAD) != 0)
2967                 {
2968                   adjust = sec->lma - (p->p_paddr + p->p_memsz);
2969                   if (adjust < 0)
2970                     adjust = 0;
2971                 }
2972               else if ((flags & SEC_ALLOC) != 0)
2973                 {
2974                   /* The section VMA must equal the file position
2975                      modulo the page size.  FIXME: I'm not sure if
2976                      this adjustment is really necessary.  We used to
2977                      not have the SEC_LOAD case just above, and then
2978                      this was necessary, but now I'm not sure.  */
2979                   if ((abfd->flags & D_PAGED) != 0)
2980                     adjust = (sec->vma - voff) % bed->maxpagesize;
2981                   else
2982                     adjust = (sec->vma - voff) % align;
2983                 }
2984               else
2985                 adjust = 0;
2986
2987               if (adjust != 0)
2988                 {
2989                   if (i == 0)
2990                     {
2991                       (* _bfd_error_handler)
2992                         (_("Error: First section in segment (%s) starts at 0x%x"),
2993                          bfd_section_name (abfd, sec), sec->lma);
2994                       (* _bfd_error_handler)
2995                         (_("       whereas segment starts at 0x%x"),
2996                          p->p_paddr);
2997
2998                       return false;
2999                     }
3000                   p->p_memsz += adjust;
3001                   off += adjust;
3002                   voff += adjust;
3003                   if ((flags & SEC_LOAD) != 0)
3004                     p->p_filesz += adjust;
3005                 }
3006
3007               sec->filepos = off;
3008
3009               /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3010                  used in a linker script we may have a section with
3011                  SEC_LOAD clear but which is supposed to have
3012                  contents.  */
3013               if ((flags & SEC_LOAD) != 0
3014                   || (flags & SEC_HAS_CONTENTS) != 0)
3015                 off += sec->_raw_size;
3016
3017               if ((flags & SEC_ALLOC) != 0)
3018                 voff += sec->_raw_size;
3019             }
3020
3021           if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
3022             {
3023               /* The actual "note" segment has i == 0.
3024                  This is the one that actually contains everything.  */
3025               if (i == 0)
3026                 {
3027                   sec->filepos = off;
3028                   p->p_filesz = sec->_raw_size;
3029                   off += sec->_raw_size;
3030                   voff = off;
3031                 }
3032               else
3033                 {
3034                   /* Fake sections -- don't need to be written.  */
3035                   sec->filepos = 0;
3036                   sec->_raw_size = 0;
3037                   flags = sec->flags = 0;
3038                 }
3039               p->p_memsz = 0;
3040               p->p_align = 1;
3041             }
3042           else
3043             {
3044               p->p_memsz += sec->_raw_size;
3045
3046               if ((flags & SEC_LOAD) != 0)
3047                 p->p_filesz += sec->_raw_size;
3048
3049               if (align > p->p_align
3050                   && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
3051                 p->p_align = align;
3052             }
3053
3054           if (! m->p_flags_valid)
3055             {
3056               p->p_flags |= PF_R;
3057               if ((flags & SEC_CODE) != 0)
3058                 p->p_flags |= PF_X;
3059               if ((flags & SEC_READONLY) == 0)
3060                 p->p_flags |= PF_W;
3061             }
3062         }
3063     }
3064
3065   /* Now that we have set the section file positions, we can set up
3066      the file positions for the non PT_LOAD segments.  */
3067   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3068        m != NULL;
3069        m = m->next, p++)
3070     {
3071       if (p->p_type != PT_LOAD && m->count > 0)
3072         {
3073           BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
3074           p->p_offset = m->sections[0]->filepos;
3075         }
3076       if (m->count == 0)
3077         {
3078           if (m->includes_filehdr)
3079             {
3080               p->p_vaddr = filehdr_vaddr;
3081               if (! m->p_paddr_valid)
3082                 p->p_paddr = filehdr_paddr;
3083             }
3084           else if (m->includes_phdrs)
3085             {
3086               p->p_vaddr = phdrs_vaddr;
3087               if (! m->p_paddr_valid)
3088                 p->p_paddr = phdrs_paddr;
3089             }
3090         }
3091     }
3092
3093   /* Clear out any program headers we allocated but did not use.  */
3094   for (; count < alloc; count++, p++)
3095     {
3096       memset (p, 0, sizeof *p);
3097       p->p_type = PT_NULL;
3098     }
3099
3100   elf_tdata (abfd)->phdr = phdrs;
3101
3102   elf_tdata (abfd)->next_file_pos = off;
3103
3104   /* Write out the program headers.  */
3105   if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0
3106       || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
3107     return false;
3108
3109   return true;
3110 }
3111
3112 /* Get the size of the program header.
3113
3114    If this is called by the linker before any of the section VMA's are set, it
3115    can't calculate the correct value for a strange memory layout.  This only
3116    happens when SIZEOF_HEADERS is used in a linker script.  In this case,
3117    SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3118    data segment (exclusive of .interp and .dynamic).
3119
3120    ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3121    will be two segments.  */
3122
3123 static bfd_size_type
3124 get_program_header_size (abfd)
3125      bfd *abfd;
3126 {
3127   size_t segs;
3128   asection *s;
3129   struct elf_backend_data *bed = get_elf_backend_data (abfd);
3130
3131   /* We can't return a different result each time we're called.  */
3132   if (elf_tdata (abfd)->program_header_size != 0)
3133     return elf_tdata (abfd)->program_header_size;
3134
3135   if (elf_tdata (abfd)->segment_map != NULL)
3136     {
3137       struct elf_segment_map *m;
3138
3139       segs = 0;
3140       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3141         ++segs;
3142       elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3143       return elf_tdata (abfd)->program_header_size;
3144     }
3145
3146   /* Assume we will need exactly two PT_LOAD segments: one for text
3147      and one for data.  */
3148   segs = 2;
3149
3150   s = bfd_get_section_by_name (abfd, ".interp");
3151   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3152     {
3153       /* If we have a loadable interpreter section, we need a
3154          PT_INTERP segment.  In this case, assume we also need a
3155          PT_PHDR segment, although that may not be true for all
3156          targets.  */
3157       segs += 2;
3158     }
3159
3160   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3161     {
3162       /* We need a PT_DYNAMIC segment.  */
3163       ++segs;
3164     }
3165
3166   for (s = abfd->sections; s != NULL; s = s->next)
3167     {
3168       if ((s->flags & SEC_LOAD) != 0
3169           && strncmp (s->name, ".note", 5) == 0)
3170         {
3171           /* We need a PT_NOTE segment.  */
3172           ++segs;
3173         }
3174     }
3175
3176   /* Let the backend count up any program headers it might need.  */
3177   if (bed->elf_backend_additional_program_headers)
3178     {
3179       int a;
3180
3181       a = (*bed->elf_backend_additional_program_headers) (abfd);
3182       if (a == -1)
3183         abort ();
3184       segs += a;
3185     }
3186
3187   elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3188   return elf_tdata (abfd)->program_header_size;
3189 }
3190
3191 /* Work out the file positions of all the sections.  This is called by
3192    _bfd_elf_compute_section_file_positions.  All the section sizes and
3193    VMAs must be known before this is called.
3194
3195    We do not consider reloc sections at this point, unless they form
3196    part of the loadable image.  Reloc sections are assigned file
3197    positions in assign_file_positions_for_relocs, which is called by
3198    write_object_contents and final_link.
3199
3200    We also don't set the positions of the .symtab and .strtab here.  */
3201
3202 static boolean
3203 assign_file_positions_except_relocs (abfd)
3204      bfd *abfd;
3205 {
3206   struct elf_obj_tdata * const tdata = elf_tdata (abfd);
3207   Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
3208   Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
3209   file_ptr off;
3210   struct elf_backend_data *bed = get_elf_backend_data (abfd);
3211
3212   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
3213       && bfd_get_format (abfd) != bfd_core)
3214     {
3215       Elf_Internal_Shdr **hdrpp;
3216       unsigned int i;
3217
3218       /* Start after the ELF header.  */
3219       off = i_ehdrp->e_ehsize;
3220
3221       /* We are not creating an executable, which means that we are
3222          not creating a program header, and that the actual order of
3223          the sections in the file is unimportant.  */
3224       for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3225         {
3226           Elf_Internal_Shdr *hdr;
3227
3228           hdr = *hdrpp;
3229           if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
3230             {
3231               hdr->sh_offset = -1;
3232               continue;
3233             }
3234           if (i == tdata->symtab_section
3235               || i == tdata->strtab_section)
3236             {
3237               hdr->sh_offset = -1;
3238               continue;
3239             }
3240
3241           off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3242         }
3243     }
3244   else
3245     {
3246       unsigned int i;
3247       Elf_Internal_Shdr **hdrpp;
3248
3249       /* Assign file positions for the loaded sections based on the
3250          assignment of sections to segments.  */
3251       if (! assign_file_positions_for_segments (abfd))
3252         return false;
3253
3254       /* Assign file positions for the other sections.  */
3255
3256       off = elf_tdata (abfd)->next_file_pos;
3257       for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3258         {
3259           Elf_Internal_Shdr *hdr;
3260
3261           hdr = *hdrpp;
3262           if (hdr->bfd_section != NULL
3263               && hdr->bfd_section->filepos != 0)
3264             hdr->sh_offset = hdr->bfd_section->filepos;
3265           else if ((hdr->sh_flags & SHF_ALLOC) != 0)
3266             {
3267               ((*_bfd_error_handler)
3268                (_("%s: warning: allocated section `%s' not in segment"),
3269                 bfd_get_filename (abfd),
3270                 (hdr->bfd_section == NULL
3271                  ? "*unknown*"
3272                  : hdr->bfd_section->name)));
3273               if ((abfd->flags & D_PAGED) != 0)
3274                 off += (hdr->sh_addr - off) % bed->maxpagesize;
3275               else
3276                 off += (hdr->sh_addr - off) % hdr->sh_addralign;
3277               off = _bfd_elf_assign_file_position_for_section (hdr, off,
3278                                                                false);
3279             }
3280           else if (hdr->sh_type == SHT_REL
3281                    || hdr->sh_type == SHT_RELA
3282                    || hdr == i_shdrpp[tdata->symtab_section]
3283                    || hdr == i_shdrpp[tdata->strtab_section])
3284             hdr->sh_offset = -1;
3285           else
3286             off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3287         }
3288     }
3289
3290   /* Place the section headers.  */
3291   off = align_file_position (off, bed->s->file_align);
3292   i_ehdrp->e_shoff = off;
3293   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
3294
3295   elf_tdata (abfd)->next_file_pos = off;
3296
3297   return true;
3298 }
3299
3300 static boolean
3301 prep_headers (abfd)
3302      bfd *abfd;
3303 {
3304   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
3305   Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
3306   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
3307   int count;
3308   struct bfd_strtab_hash *shstrtab;
3309   struct elf_backend_data *bed = get_elf_backend_data (abfd);
3310
3311   i_ehdrp = elf_elfheader (abfd);
3312   i_shdrp = elf_elfsections (abfd);
3313
3314   shstrtab = _bfd_elf_stringtab_init ();
3315   if (shstrtab == NULL)
3316     return false;
3317
3318   elf_shstrtab (abfd) = shstrtab;
3319
3320   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
3321   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
3322   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
3323   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
3324
3325   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
3326   i_ehdrp->e_ident[EI_DATA] =
3327     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
3328   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
3329
3330   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_NONE;
3331   i_ehdrp->e_ident[EI_ABIVERSION] = 0;
3332
3333   for (count = EI_PAD; count < EI_NIDENT; count++)
3334     i_ehdrp->e_ident[count] = 0;
3335
3336   if ((abfd->flags & DYNAMIC) != 0)
3337     i_ehdrp->e_type = ET_DYN;
3338   else if ((abfd->flags & EXEC_P) != 0)
3339     i_ehdrp->e_type = ET_EXEC;
3340   else if (bfd_get_format (abfd) == bfd_core)
3341     i_ehdrp->e_type = ET_CORE;
3342   else
3343     i_ehdrp->e_type = ET_REL;
3344
3345   switch (bfd_get_arch (abfd))
3346     {
3347     case bfd_arch_unknown:
3348       i_ehdrp->e_machine = EM_NONE;
3349       break;
3350     case bfd_arch_sparc:
3351       if (bfd_get_arch_size (abfd) == 64)
3352         i_ehdrp->e_machine = EM_SPARCV9;
3353       else
3354         i_ehdrp->e_machine = EM_SPARC;
3355       break;
3356     case bfd_arch_i370:
3357       i_ehdrp->e_machine = EM_S370;
3358       break;
3359     case bfd_arch_i386:
3360       if (bfd_get_arch_size (abfd) == 64)
3361         i_ehdrp->e_machine = EM_X86_64;
3362       else
3363         i_ehdrp->e_machine = EM_386;
3364       break;
3365     case bfd_arch_ia64:
3366       i_ehdrp->e_machine = EM_IA_64;
3367       break;
3368     case bfd_arch_m68hc11:
3369       i_ehdrp->e_machine = EM_68HC11;
3370       break;
3371     case bfd_arch_m68hc12:
3372       i_ehdrp->e_machine = EM_68HC12;
3373       break;
3374     case bfd_arch_s390:
3375       i_ehdrp->e_machine = EM_S390;
3376       break;
3377     case bfd_arch_m68k:
3378       i_ehdrp->e_machine = EM_68K;
3379       break;
3380     case bfd_arch_m88k:
3381       i_ehdrp->e_machine = EM_88K;
3382       break;
3383     case bfd_arch_i860:
3384       i_ehdrp->e_machine = EM_860;
3385       break;
3386     case bfd_arch_i960:
3387       i_ehdrp->e_machine = EM_960;
3388       break;
3389     case bfd_arch_mips: /* MIPS Rxxxx */
3390       i_ehdrp->e_machine = EM_MIPS;     /* only MIPS R3000 */
3391       break;
3392     case bfd_arch_hppa:
3393       i_ehdrp->e_machine = EM_PARISC;
3394       break;
3395     case bfd_arch_powerpc:
3396       i_ehdrp->e_machine = EM_PPC;
3397       break;
3398     case bfd_arch_alpha:
3399       i_ehdrp->e_machine = EM_ALPHA;
3400       break;
3401     case bfd_arch_sh:
3402       i_ehdrp->e_machine = EM_SH;
3403       break;
3404     case bfd_arch_d10v:
3405       i_ehdrp->e_machine = EM_CYGNUS_D10V;
3406       break;
3407     case bfd_arch_d30v:
3408       i_ehdrp->e_machine = EM_CYGNUS_D30V;
3409       break;
3410     case bfd_arch_fr30:
3411       i_ehdrp->e_machine = EM_CYGNUS_FR30;
3412       break;
3413     case bfd_arch_mcore:
3414       i_ehdrp->e_machine = EM_MCORE;
3415       break;
3416     case bfd_arch_avr:
3417       i_ehdrp->e_machine = EM_AVR;
3418       break;
3419     case bfd_arch_v850:
3420       switch (bfd_get_mach (abfd))
3421         {
3422         default:
3423         case 0:               i_ehdrp->e_machine = EM_CYGNUS_V850; break;
3424         }
3425       break;
3426     case bfd_arch_arc:
3427       i_ehdrp->e_machine = EM_CYGNUS_ARC;
3428       break;
3429     case bfd_arch_arm:
3430       i_ehdrp->e_machine = EM_ARM;
3431       break;
3432     case bfd_arch_m32r:
3433       i_ehdrp->e_machine = EM_CYGNUS_M32R;
3434       break;
3435     case bfd_arch_mn10200:
3436       i_ehdrp->e_machine = EM_CYGNUS_MN10200;
3437       break;
3438     case bfd_arch_mn10300:
3439       i_ehdrp->e_machine = EM_CYGNUS_MN10300;
3440       break;
3441     case bfd_arch_pj:
3442       i_ehdrp->e_machine = EM_PJ;
3443       break;
3444     case bfd_arch_cris:
3445       i_ehdrp->e_machine = EM_CRIS;
3446       break;
3447     case bfd_arch_openrisc:
3448       i_ehdrp->e_machine = EM_OPENRISC;
3449       break;
3450       /* Also note that EM_M32, AT&T WE32100 is unknown to bfd.  */
3451     default:
3452       i_ehdrp->e_machine = EM_NONE;
3453     }
3454   i_ehdrp->e_version = bed->s->ev_current;
3455   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
3456
3457   /* No program header, for now.  */
3458   i_ehdrp->e_phoff = 0;
3459   i_ehdrp->e_phentsize = 0;
3460   i_ehdrp->e_phnum = 0;
3461
3462   /* Each bfd section is section header entry.  */
3463   i_ehdrp->e_entry = bfd_get_start_address (abfd);
3464   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
3465
3466   /* If we're building an executable, we'll need a program header table.  */
3467   if (abfd->flags & EXEC_P)
3468     {
3469       /* It all happens later.  */
3470 #if 0
3471       i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
3472
3473       /* elf_build_phdrs() returns a (NULL-terminated) array of
3474          Elf_Internal_Phdrs.  */
3475       i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
3476       i_ehdrp->e_phoff = outbase;
3477       outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
3478 #endif
3479     }
3480   else
3481     {
3482       i_ehdrp->e_phentsize = 0;
3483       i_phdrp = 0;
3484       i_ehdrp->e_phoff = 0;
3485     }
3486
3487   elf_tdata (abfd)->symtab_hdr.sh_name =
3488     (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
3489   elf_tdata (abfd)->strtab_hdr.sh_name =
3490     (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
3491   elf_tdata (abfd)->shstrtab_hdr.sh_name =
3492     (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
3493   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3494       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3495       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
3496     return false;
3497
3498   return true;
3499 }
3500
3501 /* Assign file positions for all the reloc sections which are not part
3502    of the loadable file image.  */
3503
3504 void
3505 _bfd_elf_assign_file_positions_for_relocs (abfd)
3506      bfd *abfd;
3507 {
3508   file_ptr off;
3509   unsigned int i;
3510   Elf_Internal_Shdr **shdrpp;
3511
3512   off = elf_tdata (abfd)->next_file_pos;
3513
3514   for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
3515        i < elf_elfheader (abfd)->e_shnum;
3516        i++, shdrpp++)
3517     {
3518       Elf_Internal_Shdr *shdrp;
3519
3520       shdrp = *shdrpp;
3521       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
3522           && shdrp->sh_offset == -1)
3523         off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
3524     }
3525
3526   elf_tdata (abfd)->next_file_pos = off;
3527 }
3528
3529 boolean
3530 _bfd_elf_write_object_contents (abfd)
3531      bfd *abfd;
3532 {
3533   struct elf_backend_data *bed = get_elf_backend_data (abfd);
3534   Elf_Internal_Ehdr *i_ehdrp;
3535   Elf_Internal_Shdr **i_shdrp;
3536   boolean failed;
3537   unsigned int count;
3538
3539   if (! abfd->output_has_begun
3540       && ! _bfd_elf_compute_section_file_positions
3541              (abfd, (struct bfd_link_info *) NULL))
3542     return false;
3543
3544   i_shdrp = elf_elfsections (abfd);
3545   i_ehdrp = elf_elfheader (abfd);
3546
3547   failed = false;
3548   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
3549   if (failed)
3550     return false;
3551
3552   _bfd_elf_assign_file_positions_for_relocs (abfd);
3553
3554   /* After writing the headers, we need to write the sections too...  */
3555   for (count = 1; count < i_ehdrp->e_shnum; count++)
3556     {
3557       if (bed->elf_backend_section_processing)
3558         (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
3559       if (i_shdrp[count]->contents)
3560         {
3561           if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
3562               || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
3563                              1, abfd)
3564                   != i_shdrp[count]->sh_size))
3565             return false;
3566         }
3567     }
3568
3569   /* Write out the section header names.  */
3570   if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
3571       || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
3572     return false;
3573
3574   if (bed->elf_backend_final_write_processing)
3575     (*bed->elf_backend_final_write_processing) (abfd,
3576                                                 elf_tdata (abfd)->linker);
3577
3578   return bed->s->write_shdrs_and_ehdr (abfd);
3579 }
3580
3581 boolean
3582 _bfd_elf_write_corefile_contents (abfd)
3583      bfd *abfd;
3584 {
3585   /* Hopefully this can be done just like an object file.  */
3586   return _bfd_elf_write_object_contents (abfd);
3587 }
3588
3589 /* Given a section, search the header to find them.  */
3590
3591 int
3592 _bfd_elf_section_from_bfd_section (abfd, asect)
3593      bfd *abfd;
3594      struct sec *asect;
3595 {
3596   struct elf_backend_data *bed = get_elf_backend_data (abfd);
3597   Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
3598   int index;
3599   Elf_Internal_Shdr *hdr;
3600   int maxindex = elf_elfheader (abfd)->e_shnum;
3601
3602   for (index = 0; index < maxindex; index++)
3603     {
3604       hdr = i_shdrp[index];
3605       if (hdr->bfd_section == asect)
3606         return index;
3607     }
3608
3609   if (bed->elf_backend_section_from_bfd_section)
3610     {
3611       for (index = 0; index < maxindex; index++)
3612         {
3613           int retval;
3614
3615           hdr = i_shdrp[index];
3616           retval = index;
3617           if ((*bed->elf_backend_section_from_bfd_section)
3618               (abfd, hdr, asect, &retval))
3619             return retval;
3620         }
3621     }
3622
3623   if (bfd_is_abs_section (asect))
3624     return SHN_ABS;
3625   if (bfd_is_com_section (asect))
3626     return SHN_COMMON;
3627   if (bfd_is_und_section (asect))
3628     return SHN_UNDEF;
3629
3630   bfd_set_error (bfd_error_nonrepresentable_section);
3631
3632   return -1;
3633 }
3634
3635 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3636    on error.  */
3637
3638 int
3639 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
3640      bfd *abfd;
3641      asymbol **asym_ptr_ptr;
3642 {
3643   asymbol *asym_ptr = *asym_ptr_ptr;
3644   int idx;
3645   flagword flags = asym_ptr->flags;
3646
3647   /* When gas creates relocations against local labels, it creates its
3648      own symbol for the section, but does put the symbol into the
3649      symbol chain, so udata is 0.  When the linker is generating
3650      relocatable output, this section symbol may be for one of the
3651      input sections rather than the output section.  */
3652   if (asym_ptr->udata.i == 0
3653       && (flags & BSF_SECTION_SYM)
3654       && asym_ptr->section)
3655     {
3656       int indx;
3657
3658       if (asym_ptr->section->output_section != NULL)
3659         indx = asym_ptr->section->output_section->index;
3660       else
3661         indx = asym_ptr->section->index;
3662       if (indx < elf_num_section_syms (abfd)
3663           && elf_section_syms (abfd)[indx] != NULL)
3664         asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
3665     }
3666
3667   idx = asym_ptr->udata.i;
3668
3669   if (idx == 0)
3670     {
3671       /* This case can occur when using --strip-symbol on a symbol
3672          which is used in a relocation entry.  */
3673       (*_bfd_error_handler)
3674         (_("%s: symbol `%s' required but not present"),
3675          bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
3676       bfd_set_error (bfd_error_no_symbols);
3677       return -1;
3678     }
3679
3680 #if DEBUG & 4
3681   {
3682     fprintf (stderr,
3683              _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3684              (long) asym_ptr, asym_ptr->name, idx, flags,
3685              elf_symbol_flags (flags));
3686     fflush (stderr);
3687   }
3688 #endif
3689
3690   return idx;
3691 }
3692
3693 /* Copy private BFD data.  This copies any program header information.  */
3694
3695 static boolean
3696 copy_private_bfd_data (ibfd, obfd)
3697      bfd *ibfd;
3698      bfd *obfd;
3699 {
3700   Elf_Internal_Ehdr *       iehdr;
3701   struct elf_segment_map *  map;
3702   struct elf_segment_map *  map_first;
3703   struct elf_segment_map ** pointer_to_map;
3704   Elf_Internal_Phdr *       segment;
3705   asection *                section;
3706   unsigned int              i;
3707   unsigned int              num_segments;
3708   boolean                   phdr_included = false;
3709   bfd_vma                   maxpagesize;
3710   struct elf_segment_map *  phdr_adjust_seg = NULL;
3711   unsigned int              phdr_adjust_num = 0;
3712
3713   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3714       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3715     return true;
3716
3717   if (elf_tdata (ibfd)->phdr == NULL)
3718     return true;
3719
3720   iehdr = elf_elfheader (ibfd);
3721
3722   map_first = NULL;
3723   pointer_to_map = &map_first;
3724
3725   num_segments = elf_elfheader (ibfd)->e_phnum;
3726   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
3727
3728   /* Returns the end address of the segment + 1.  */
3729 #define SEGMENT_END(segment, start)                     \
3730   (start + (segment->p_memsz > segment->p_filesz        \
3731    ? segment->p_memsz : segment->p_filesz))
3732
3733   /* Returns true if the given section is contained within
3734      the given segment.  VMA addresses are compared.  */
3735 #define IS_CONTAINED_BY_VMA(section, segment)           \
3736   (section->vma >= segment->p_vaddr                     \
3737    && (section->vma + section->_raw_size)               \
3738    <= (SEGMENT_END (segment, segment->p_vaddr)))
3739
3740   /* Returns true if the given section is contained within
3741      the given segment.  LMA addresses are compared.  */
3742 #define IS_CONTAINED_BY_LMA(section, segment, base)     \
3743     (section->lma >= base                               \
3744      && (section->lma + section->_raw_size)             \
3745      <= SEGMENT_END (segment, base))
3746
3747   /* Special case: corefile "NOTE" section containing regs, prpsinfo etc.  */
3748 #define IS_COREFILE_NOTE(p, s)                          \
3749             (p->p_type == PT_NOTE                       \
3750              && bfd_get_format (ibfd) == bfd_core       \
3751              && s->vma == 0 && s->lma == 0              \
3752              && (bfd_vma) s->filepos >= p->p_offset     \
3753              && (bfd_vma) s->filepos + s->_raw_size     \
3754              <= p->p_offset + p->p_filesz)
3755
3756   /* The complicated case when p_vaddr is 0 is to handle the Solaris
3757      linker, which generates a PT_INTERP section with p_vaddr and
3758      p_memsz set to 0.  */
3759 #define IS_SOLARIS_PT_INTERP(p, s)                      \
3760             (   p->p_vaddr == 0                         \
3761              && p->p_filesz > 0                         \
3762              && (s->flags & SEC_HAS_CONTENTS) != 0      \
3763              && s->_raw_size > 0                        \
3764              && (bfd_vma) s->filepos >= p->p_offset     \
3765              && ((bfd_vma) s->filepos + s->_raw_size    \
3766                      <= p->p_offset + p->p_filesz))
3767
3768   /* Decide if the given section should be included in the given segment.
3769      A section will be included if:
3770        1. It is within the address space of the segment,
3771        2. It is an allocated segment,
3772        3. There is an output section associated with it,
3773        4. The section has not already been allocated to a previous segment.  */
3774 #define INCLUDE_SECTION_IN_SEGMENT(section, segment)    \
3775   ((((IS_CONTAINED_BY_VMA (section, segment)            \
3776       || IS_SOLARIS_PT_INTERP (segment, section))       \
3777      && (section->flags & SEC_ALLOC) != 0)              \
3778     || IS_COREFILE_NOTE (segment, section))             \
3779    && section->output_section != NULL                   \
3780    && section->segment_mark == false)
3781
3782   /* Returns true iff seg1 starts after the end of seg2.  */
3783 #define SEGMENT_AFTER_SEGMENT(seg1, seg2)               \
3784     (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
3785
3786   /* Returns true iff seg1 and seg2 overlap.  */
3787 #define SEGMENT_OVERLAPS(seg1, seg2)                    \
3788   (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
3789
3790   /* Initialise the segment mark field.  */
3791   for (section = ibfd->sections; section != NULL; section = section->next)
3792     section->segment_mark = false;
3793
3794   /* Scan through the segments specified in the program header
3795      of the input BFD.  For this first scan we look for overlaps
3796      in the loadable segments.  These can be created by wierd
3797      parameters to objcopy.  */
3798   for (i = 0, segment = elf_tdata (ibfd)->phdr;
3799        i < num_segments;
3800        i++, segment++)
3801     {
3802       unsigned int j;
3803       Elf_Internal_Phdr *segment2;
3804
3805       if (segment->p_type != PT_LOAD)
3806         continue;
3807
3808       /* Determine if this segment overlaps any previous segments.  */
3809       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
3810         {
3811           bfd_signed_vma extra_length;
3812
3813           if (segment2->p_type != PT_LOAD
3814               || ! SEGMENT_OVERLAPS (segment, segment2))
3815             continue;
3816
3817           /* Merge the two segments together.  */
3818           if (segment2->p_vaddr < segment->p_vaddr)
3819             {
3820               /* Extend SEGMENT2 to include SEGMENT and then delete
3821                  SEGMENT.  */
3822               extra_length =
3823                 SEGMENT_END (segment, segment->p_vaddr)
3824                 - SEGMENT_END (segment2, segment2->p_vaddr);
3825
3826               if (extra_length > 0)
3827                 {
3828                   segment2->p_memsz  += extra_length;
3829                   segment2->p_filesz += extra_length;
3830                 }
3831
3832               segment->p_type = PT_NULL;
3833
3834               /* Since we have deleted P we must restart the outer loop.  */
3835               i = 0;
3836               segment = elf_tdata (ibfd)->phdr;
3837               break;
3838             }
3839           else
3840             {
3841               /* Extend SEGMENT to include SEGMENT2 and then delete
3842                  SEGMENT2.  */
3843               extra_length =
3844                 SEGMENT_END (segment2, segment2->p_vaddr)
3845                 - SEGMENT_END (segment, segment->p_vaddr);
3846
3847               if (extra_length > 0)
3848                 {
3849                   segment->p_memsz  += extra_length;
3850                   segment->p_filesz += extra_length;
3851                 }
3852
3853               segment2->p_type = PT_NULL;
3854             }
3855         }
3856     }
3857
3858   /* The second scan attempts to assign sections to segments.  */
3859   for (i = 0, segment = elf_tdata (ibfd)->phdr;
3860        i < num_segments;
3861        i ++, segment ++)
3862     {
3863       unsigned int  section_count;
3864       asection **   sections;
3865       asection *    output_section;
3866       unsigned int  isec;
3867       bfd_vma       matching_lma;
3868       bfd_vma       suggested_lma;
3869       unsigned int  j;
3870
3871       if (segment->p_type == PT_NULL)
3872         continue;
3873
3874       /* Compute how many sections might be placed into this segment.  */
3875       section_count = 0;
3876       for (section = ibfd->sections; section != NULL; section = section->next)
3877         if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
3878           ++section_count;
3879
3880       /* Allocate a segment map big enough to contain all of the
3881          sections we have selected.  */
3882       map = ((struct elf_segment_map *)
3883            bfd_alloc (obfd,
3884                       (sizeof (struct elf_segment_map)
3885                        + ((size_t) section_count - 1) * sizeof (asection *))));
3886       if (map == NULL)
3887         return false;
3888
3889       /* Initialise the fields of the segment map.  Default to
3890          using the physical address of the segment in the input BFD.  */
3891       map->next          = NULL;
3892       map->p_type        = segment->p_type;
3893       map->p_flags       = segment->p_flags;
3894       map->p_flags_valid = 1;
3895       map->p_paddr       = segment->p_paddr;
3896       map->p_paddr_valid = 1;
3897
3898       /* Determine if this segment contains the ELF file header
3899          and if it contains the program headers themselves.  */
3900       map->includes_filehdr = (segment->p_offset == 0
3901                                && segment->p_filesz >= iehdr->e_ehsize);
3902
3903       map->includes_phdrs = 0;
3904
3905       if (! phdr_included || segment->p_type != PT_LOAD)
3906         {
3907           map->includes_phdrs =
3908             (segment->p_offset <= (bfd_vma) iehdr->e_phoff
3909              && (segment->p_offset + segment->p_filesz
3910                  >= ((bfd_vma) iehdr->e_phoff
3911                      + iehdr->e_phnum * iehdr->e_phentsize)));
3912
3913           if (segment->p_type == PT_LOAD && map->includes_phdrs)
3914             phdr_included = true;
3915         }
3916
3917       if (section_count == 0)
3918         {
3919           /* Special segments, such as the PT_PHDR segment, may contain
3920              no sections, but ordinary, loadable segments should contain
3921              something.  */
3922           if (segment->p_type == PT_LOAD)
3923               _bfd_error_handler
3924                 (_("%s: warning: Empty loadable segment detected\n"),
3925                  bfd_get_filename (ibfd));
3926
3927           map->count = 0;
3928           *pointer_to_map = map;
3929           pointer_to_map = &map->next;
3930
3931           continue;
3932         }
3933
3934       /* Now scan the sections in the input BFD again and attempt
3935          to add their corresponding output sections to the segment map.
3936          The problem here is how to handle an output section which has
3937          been moved (ie had its LMA changed).  There are four possibilities:
3938
3939          1. None of the sections have been moved.
3940             In this case we can continue to use the segment LMA from the
3941             input BFD.
3942
3943          2. All of the sections have been moved by the same amount.
3944             In this case we can change the segment's LMA to match the LMA
3945             of the first section.
3946
3947          3. Some of the sections have been moved, others have not.
3948             In this case those sections which have not been moved can be
3949             placed in the current segment which will have to have its size,
3950             and possibly its LMA changed, and a new segment or segments will
3951             have to be created to contain the other sections.
3952
3953          4. The sections have been moved, but not be the same amount.
3954             In this case we can change the segment's LMA to match the LMA
3955             of the first section and we will have to create a new segment
3956             or segments to contain the other sections.
3957
3958          In order to save time, we allocate an array to hold the section
3959          pointers that we are interested in.  As these sections get assigned
3960          to a segment, they are removed from this array.  */
3961
3962       sections = (asection **) bfd_malloc
3963         (sizeof (asection *) * section_count);
3964       if (sections == NULL)
3965         return false;
3966
3967       /* Step One: Scan for segment vs section LMA conflicts.
3968          Also add the sections to the section array allocated above.
3969          Also add the sections to the current segment.  In the common
3970          case, where the sections have not been moved, this means that
3971          we have completely filled the segment, and there is nothing
3972          more to do.  */
3973       isec = 0;
3974       matching_lma = 0;
3975       suggested_lma = 0;
3976
3977       for (j = 0, section = ibfd->sections;
3978            section != NULL;
3979            section = section->next)
3980         {
3981           if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
3982             {
3983               output_section = section->output_section;
3984
3985               sections[j ++] = section;
3986
3987               /* The Solaris native linker always sets p_paddr to 0.
3988                  We try to catch that case here, and set it to the
3989                  correct value.  */
3990               if (segment->p_paddr == 0
3991                   && segment->p_vaddr != 0
3992                   && isec == 0
3993                   && output_section->lma != 0
3994                   && (output_section->vma == (segment->p_vaddr
3995                                               + (map->includes_filehdr
3996                                                  ? iehdr->e_ehsize
3997                                                  : 0)
3998                                               + (map->includes_phdrs
3999                                                  ? iehdr->e_phnum * iehdr->e_phentsize
4000                                                  : 0))))
4001                 map->p_paddr = segment->p_vaddr;
4002
4003               /* Match up the physical address of the segment with the
4004                  LMA address of the output section.  */
4005               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4006                   || IS_COREFILE_NOTE (segment, section))
4007                 {
4008                   if (matching_lma == 0)
4009                     matching_lma = output_section->lma;
4010
4011                   /* We assume that if the section fits within the segment
4012                      then it does not overlap any other section within that
4013                      segment.  */
4014                   map->sections[isec ++] = output_section;
4015                 }
4016               else if (suggested_lma == 0)
4017                 suggested_lma = output_section->lma;
4018             }
4019         }
4020
4021       BFD_ASSERT (j == section_count);
4022
4023       /* Step Two: Adjust the physical address of the current segment,
4024          if necessary.  */
4025       if (isec == section_count)
4026         {
4027           /* All of the sections fitted within the segment as currently
4028              specified.  This is the default case.  Add the segment to
4029              the list of built segments and carry on to process the next
4030              program header in the input BFD.  */
4031           map->count = section_count;
4032           *pointer_to_map = map;
4033           pointer_to_map = &map->next;
4034
4035           free (sections);
4036           continue;
4037         }
4038       else
4039         {
4040           if (matching_lma != 0)
4041             {
4042               /* At least one section fits inside the current segment.
4043                  Keep it, but modify its physical address to match the
4044                  LMA of the first section that fitted.  */
4045               map->p_paddr = matching_lma;
4046             }
4047           else
4048             {
4049               /* None of the sections fitted inside the current segment.
4050                  Change the current segment's physical address to match
4051                  the LMA of the first section.  */
4052               map->p_paddr = suggested_lma;
4053             }
4054
4055           /* Offset the segment physical address from the lma
4056              to allow for space taken up by elf headers.  */
4057           if (map->includes_filehdr)
4058             map->p_paddr -= iehdr->e_ehsize;
4059
4060           if (map->includes_phdrs)
4061             {
4062               map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
4063
4064               /* iehdr->e_phnum is just an estimate of the number
4065                  of program headers that we will need.  Make a note
4066                  here of the number we used and the segment we chose
4067                  to hold these headers, so that we can adjust the
4068                  offset when we know the correct value.  */
4069               phdr_adjust_num = iehdr->e_phnum;
4070               phdr_adjust_seg = map;
4071             }
4072         }
4073
4074       /* Step Three: Loop over the sections again, this time assigning
4075          those that fit to the current segment and remvoing them from the
4076          sections array; but making sure not to leave large gaps.  Once all
4077          possible sections have been assigned to the current segment it is
4078          added to the list of built segments and if sections still remain
4079          to be assigned, a new segment is constructed before repeating
4080          the loop.  */
4081       isec = 0;
4082       do
4083         {
4084           map->count = 0;
4085           suggested_lma = 0;
4086
4087           /* Fill the current segment with sections that fit.  */
4088           for (j = 0; j < section_count; j++)
4089             {
4090               section = sections[j];
4091
4092               if (section == NULL)
4093                 continue;
4094
4095               output_section = section->output_section;
4096
4097               BFD_ASSERT (output_section != NULL);
4098
4099               if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4100                   || IS_COREFILE_NOTE (segment, section))
4101                 {
4102                   if (map->count == 0)
4103                     {
4104                       /* If the first section in a segment does not start at
4105                          the beginning of the segment, then something is
4106                          wrong.  */
4107                       if (output_section->lma !=
4108                           (map->p_paddr
4109                            + (map->includes_filehdr ? iehdr->e_ehsize : 0)
4110                            + (map->includes_phdrs
4111                               ? iehdr->e_phnum * iehdr->e_phentsize
4112                               : 0)))
4113                         abort ();
4114                     }
4115                   else
4116                     {
4117                       asection * prev_sec;
4118
4119                       prev_sec = map->sections[map->count - 1];
4120
4121                       /* If the gap between the end of the previous section
4122                          and the start of this section is more than
4123                          maxpagesize then we need to start a new segment.  */
4124                       if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size, maxpagesize)
4125                           < BFD_ALIGN (output_section->lma, maxpagesize))
4126                           || ((prev_sec->lma + prev_sec->_raw_size) > output_section->lma))
4127                         {
4128                           if (suggested_lma == 0)
4129                             suggested_lma = output_section->lma;
4130
4131                           continue;
4132                         }
4133                     }
4134
4135                   map->sections[map->count++] = output_section;
4136                   ++isec;
4137                   sections[j] = NULL;
4138                   section->segment_mark = true;
4139                 }
4140               else if (suggested_lma == 0)
4141                 suggested_lma = output_section->lma;
4142             }
4143
4144           BFD_ASSERT (map->count > 0);
4145
4146           /* Add the current segment to the list of built segments.  */
4147           *pointer_to_map = map;
4148           pointer_to_map = &map->next;
4149
4150           if (isec < section_count)
4151             {
4152               /* We still have not allocated all of the sections to
4153                  segments.  Create a new segment here, initialise it
4154                  and carry on looping.  */
4155               map = ((struct elf_segment_map *)
4156                      bfd_alloc (obfd,
4157                                 (sizeof (struct elf_segment_map)
4158                                  + ((size_t) section_count - 1)
4159                                  * sizeof (asection *))));
4160               if (map == NULL)
4161                 return false;
4162
4163               /* Initialise the fields of the segment map.  Set the physical
4164                  physical address to the LMA of the first section that has
4165                  not yet been assigned.  */
4166               map->next             = NULL;
4167               map->p_type           = segment->p_type;
4168               map->p_flags          = segment->p_flags;
4169               map->p_flags_valid    = 1;
4170               map->p_paddr          = suggested_lma;
4171               map->p_paddr_valid    = 1;
4172               map->includes_filehdr = 0;
4173               map->includes_phdrs   = 0;
4174             }
4175         }
4176       while (isec < section_count);
4177
4178       free (sections);
4179     }
4180
4181   /* The Solaris linker creates program headers in which all the
4182      p_paddr fields are zero.  When we try to objcopy or strip such a
4183      file, we get confused.  Check for this case, and if we find it
4184      reset the p_paddr_valid fields.  */
4185   for (map = map_first; map != NULL; map = map->next)
4186     if (map->p_paddr != 0)
4187       break;
4188   if (map == NULL)
4189     {
4190       for (map = map_first; map != NULL; map = map->next)
4191         map->p_paddr_valid = 0;
4192     }
4193
4194   elf_tdata (obfd)->segment_map = map_first;
4195
4196   /* If we had to estimate the number of program headers that were
4197      going to be needed, then check our estimate know and adjust
4198      the offset if necessary.  */
4199   if (phdr_adjust_seg != NULL)
4200     {
4201       unsigned int count;
4202
4203       for (count = 0, map = map_first; map != NULL; map = map->next)
4204         count++;
4205
4206       if (count > phdr_adjust_num)
4207         phdr_adjust_seg->p_paddr
4208           -= (count - phdr_adjust_num) * iehdr->e_phentsize;
4209     }
4210
4211 #if 0
4212   /* Final Step: Sort the segments into ascending order of physical
4213      address.  */
4214   if (map_first != NULL)
4215     {
4216       struct elf_segment_map *prev;
4217
4218       prev = map_first;
4219       for (map = map_first->next; map != NULL; prev = map, map = map->next)
4220         {
4221           /* Yes I know - its a bubble sort....  */
4222           if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
4223             {
4224               /* Swap map and map->next.  */
4225               prev->next = map->next;
4226               map->next = map->next->next;
4227               prev->next->next = map;
4228
4229               /* Restart loop.  */
4230               map = map_first;
4231             }
4232         }
4233     }
4234 #endif
4235
4236 #undef SEGMENT_END
4237 #undef IS_CONTAINED_BY_VMA
4238 #undef IS_CONTAINED_BY_LMA
4239 #undef IS_COREFILE_NOTE
4240 #undef IS_SOLARIS_PT_INTERP
4241 #undef INCLUDE_SECTION_IN_SEGMENT
4242 #undef SEGMENT_AFTER_SEGMENT
4243 #undef SEGMENT_OVERLAPS
4244   return true;
4245 }
4246
4247 /* Copy private section information.  This copies over the entsize
4248    field, and sometimes the info field.  */
4249
4250 boolean
4251 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
4252      bfd *ibfd;
4253      asection *isec;
4254      bfd *obfd;
4255      asection *osec;
4256 {
4257   Elf_Internal_Shdr *ihdr, *ohdr;
4258
4259   if (ibfd->xvec->flavour != bfd_target_elf_flavour
4260       || obfd->xvec->flavour != bfd_target_elf_flavour)
4261     return true;
4262
4263   /* Copy over private BFD data if it has not already been copied.
4264      This must be done here, rather than in the copy_private_bfd_data
4265      entry point, because the latter is called after the section
4266      contents have been set, which means that the program headers have
4267      already been worked out.  */
4268   if (elf_tdata (obfd)->segment_map == NULL
4269       && elf_tdata (ibfd)->phdr != NULL)
4270     {
4271       asection *s;
4272
4273       /* Only set up the segments if there are no more SEC_ALLOC
4274          sections.  FIXME: This won't do the right thing if objcopy is
4275          used to remove the last SEC_ALLOC section, since objcopy
4276          won't call this routine in that case.  */
4277       for (s = isec->next; s != NULL; s = s->next)
4278         if ((s->flags & SEC_ALLOC) != 0)
4279           break;
4280       if (s == NULL)
4281         {
4282           if (! copy_private_bfd_data (ibfd, obfd))
4283             return false;
4284         }
4285     }
4286
4287   ihdr = &elf_section_data (isec)->this_hdr;
4288   ohdr = &elf_section_data (osec)->this_hdr;
4289
4290   ohdr->sh_entsize = ihdr->sh_entsize;
4291
4292   if (ihdr->sh_type == SHT_SYMTAB
4293       || ihdr->sh_type == SHT_DYNSYM
4294       || ihdr->sh_type == SHT_GNU_verneed
4295       || ihdr->sh_type == SHT_GNU_verdef)
4296     ohdr->sh_info = ihdr->sh_info;
4297
4298   elf_section_data (osec)->use_rela_p
4299     = elf_section_data (isec)->use_rela_p;
4300
4301   return true;
4302 }
4303
4304 /* Copy private symbol information.  If this symbol is in a section
4305    which we did not map into a BFD section, try to map the section
4306    index correctly.  We use special macro definitions for the mapped
4307    section indices; these definitions are interpreted by the
4308    swap_out_syms function.  */
4309
4310 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
4311 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
4312 #define MAP_STRTAB (SHN_LORESERVE - 3)
4313 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
4314
4315 boolean
4316 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
4317      bfd *ibfd;
4318      asymbol *isymarg;
4319      bfd *obfd;
4320      asymbol *osymarg;
4321 {
4322   elf_symbol_type *isym, *osym;
4323
4324   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4325       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4326     return true;
4327
4328   isym = elf_symbol_from (ibfd, isymarg);
4329   osym = elf_symbol_from (obfd, osymarg);
4330
4331   if (isym != NULL
4332       && osym != NULL
4333       && bfd_is_abs_section (isym->symbol.section))
4334     {
4335       unsigned int shndx;
4336
4337       shndx = isym->internal_elf_sym.st_shndx;
4338       if (shndx == elf_onesymtab (ibfd))
4339         shndx = MAP_ONESYMTAB;
4340       else if (shndx == elf_dynsymtab (ibfd))
4341         shndx = MAP_DYNSYMTAB;
4342       else if (shndx == elf_tdata (ibfd)->strtab_section)
4343         shndx = MAP_STRTAB;
4344       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
4345         shndx = MAP_SHSTRTAB;
4346       osym->internal_elf_sym.st_shndx = shndx;
4347     }
4348
4349   return true;
4350 }
4351
4352 /* Swap out the symbols.  */
4353
4354 static boolean
4355 swap_out_syms (abfd, sttp, relocatable_p)
4356      bfd *abfd;
4357      struct bfd_strtab_hash **sttp;
4358      int relocatable_p;
4359 {
4360   struct elf_backend_data *bed = get_elf_backend_data (abfd);
4361
4362   if (!elf_map_symbols (abfd))
4363     return false;
4364
4365   /* Dump out the symtabs.  */
4366   {
4367     int symcount = bfd_get_symcount (abfd);
4368     asymbol **syms = bfd_get_outsymbols (abfd);
4369     struct bfd_strtab_hash *stt;
4370     Elf_Internal_Shdr *symtab_hdr;
4371     Elf_Internal_Shdr *symstrtab_hdr;
4372     char *outbound_syms;
4373     int idx;
4374
4375     stt = _bfd_elf_stringtab_init ();
4376     if (stt == NULL)
4377       return false;
4378
4379     symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4380     symtab_hdr->sh_type = SHT_SYMTAB;
4381     symtab_hdr->sh_entsize = bed->s->sizeof_sym;
4382     symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
4383     symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
4384     symtab_hdr->sh_addralign = bed->s->file_align;
4385
4386     symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
4387     symstrtab_hdr->sh_type = SHT_STRTAB;
4388
4389     outbound_syms = bfd_alloc (abfd,
4390                                (1 + symcount) * bed->s->sizeof_sym);
4391     if (outbound_syms == NULL)
4392       return false;
4393     symtab_hdr->contents = (PTR) outbound_syms;
4394
4395     /* now generate the data (for "contents") */
4396     {
4397       /* Fill in zeroth symbol and swap it out.  */
4398       Elf_Internal_Sym sym;
4399       sym.st_name = 0;
4400       sym.st_value = 0;
4401       sym.st_size = 0;
4402       sym.st_info = 0;
4403       sym.st_other = 0;
4404       sym.st_shndx = SHN_UNDEF;
4405       bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4406       outbound_syms += bed->s->sizeof_sym;
4407     }
4408     for (idx = 0; idx < symcount; idx++)
4409       {
4410         Elf_Internal_Sym sym;
4411         bfd_vma value = syms[idx]->value;
4412         elf_symbol_type *type_ptr;
4413         flagword flags = syms[idx]->flags;
4414         int type;
4415
4416         if ((flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
4417           {
4418             /* Local section symbols have no name.  */
4419             sym.st_name = 0;
4420           }
4421         else
4422           {
4423             sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
4424                                                               syms[idx]->name,
4425                                                               true, false);
4426             if (sym.st_name == (unsigned long) -1)
4427               return false;
4428           }
4429
4430         type_ptr = elf_symbol_from (abfd, syms[idx]);
4431
4432         if ((flags & BSF_SECTION_SYM) == 0
4433             && bfd_is_com_section (syms[idx]->section))
4434           {
4435             /* ELF common symbols put the alignment into the `value' field,
4436                and the size into the `size' field.  This is backwards from
4437                how BFD handles it, so reverse it here.  */
4438             sym.st_size = value;
4439             if (type_ptr == NULL
4440                 || type_ptr->internal_elf_sym.st_value == 0)
4441               sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
4442             else
4443               sym.st_value = type_ptr->internal_elf_sym.st_value;
4444             sym.st_shndx = _bfd_elf_section_from_bfd_section
4445               (abfd, syms[idx]->section);
4446           }
4447         else
4448           {
4449             asection *sec = syms[idx]->section;
4450             int shndx;
4451
4452             if (sec->output_section)
4453               {
4454                 value += sec->output_offset;
4455                 sec = sec->output_section;
4456               }
4457             /* Don't add in the section vma for relocatable output.  */
4458             if (! relocatable_p)
4459               value += sec->vma;
4460             sym.st_value = value;
4461             sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
4462
4463             if (bfd_is_abs_section (sec)
4464                 && type_ptr != NULL
4465                 && type_ptr->internal_elf_sym.st_shndx != 0)
4466               {
4467                 /* This symbol is in a real ELF section which we did
4468                    not create as a BFD section.  Undo the mapping done
4469                    by copy_private_symbol_data.  */
4470                 shndx = type_ptr->internal_elf_sym.st_shndx;
4471                 switch (shndx)
4472                   {
4473                   case MAP_ONESYMTAB:
4474                     shndx = elf_onesymtab (abfd);
4475                     break;
4476                   case MAP_DYNSYMTAB:
4477                     shndx = elf_dynsymtab (abfd);
4478                     break;
4479                   case MAP_STRTAB:
4480                     shndx = elf_tdata (abfd)->strtab_section;
4481                     break;
4482                   case MAP_SHSTRTAB:
4483                     shndx = elf_tdata (abfd)->shstrtab_section;
4484                     break;
4485                   default:
4486                     break;
4487                   }
4488               }
4489             else
4490               {
4491                 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
4492
4493                 if (shndx == -1)
4494                   {
4495                     asection *sec2;
4496
4497                     /* Writing this would be a hell of a lot easier if
4498                        we had some decent documentation on bfd, and
4499                        knew what to expect of the library, and what to
4500                        demand of applications.  For example, it
4501                        appears that `objcopy' might not set the
4502                        section of a symbol to be a section that is
4503                        actually in the output file.  */
4504                     sec2 = bfd_get_section_by_name (abfd, sec->name);
4505                     BFD_ASSERT (sec2 != 0);
4506                     shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
4507                     BFD_ASSERT (shndx != -1);
4508                   }
4509               }
4510
4511             sym.st_shndx = shndx;
4512           }
4513
4514         if ((flags & BSF_FUNCTION) != 0)
4515           type = STT_FUNC;
4516         else if ((flags & BSF_OBJECT) != 0)
4517           type = STT_OBJECT;
4518         else
4519           type = STT_NOTYPE;
4520
4521         /* Processor-specific types */
4522         if (type_ptr != NULL
4523             && bed->elf_backend_get_symbol_type)
4524           type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
4525
4526         if (flags & BSF_SECTION_SYM)
4527           {
4528             if (flags & BSF_GLOBAL)
4529               sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
4530             else
4531               sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
4532           }
4533         else if (bfd_is_com_section (syms[idx]->section))
4534           sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
4535         else if (bfd_is_und_section (syms[idx]->section))
4536           sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
4537                                       ? STB_WEAK
4538                                       : STB_GLOBAL),
4539                                      type);
4540         else if (flags & BSF_FILE)
4541           sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
4542         else
4543           {
4544             int bind = STB_LOCAL;
4545
4546             if (flags & BSF_LOCAL)
4547               bind = STB_LOCAL;
4548             else if (flags & BSF_WEAK)
4549               bind = STB_WEAK;
4550             else if (flags & BSF_GLOBAL)
4551               bind = STB_GLOBAL;
4552
4553             sym.st_info = ELF_ST_INFO (bind, type);
4554           }
4555
4556         if (type_ptr != NULL)
4557           sym.st_other = type_ptr->internal_elf_sym.st_other;
4558         else
4559           sym.st_other = 0;
4560
4561         bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4562         outbound_syms += bed->s->sizeof_sym;
4563       }
4564
4565     *sttp = stt;
4566     symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
4567     symstrtab_hdr->sh_type = SHT_STRTAB;
4568
4569     symstrtab_hdr->sh_flags = 0;
4570     symstrtab_hdr->sh_addr = 0;
4571     symstrtab_hdr->sh_entsize = 0;
4572     symstrtab_hdr->sh_link = 0;
4573     symstrtab_hdr->sh_info = 0;
4574     symstrtab_hdr->sh_addralign = 1;
4575   }
4576
4577   return true;
4578 }
4579
4580 /* Return the number of bytes required to hold the symtab vector.
4581
4582    Note that we base it on the count plus 1, since we will null terminate
4583    the vector allocated based on this size.  However, the ELF symbol table
4584    always has a dummy entry as symbol #0, so it ends up even.  */
4585
4586 long
4587 _bfd_elf_get_symtab_upper_bound (abfd)
4588      bfd *abfd;
4589 {
4590   long symcount;
4591   long symtab_size;
4592   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
4593
4594   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4595   symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4596
4597   return symtab_size;
4598 }
4599
4600 long
4601 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
4602      bfd *abfd;
4603 {
4604   long symcount;
4605   long symtab_size;
4606   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
4607
4608   if (elf_dynsymtab (abfd) == 0)
4609     {
4610       bfd_set_error (bfd_error_invalid_operation);
4611       return -1;
4612     }
4613
4614   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4615   symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4616
4617   return symtab_size;
4618 }
4619
4620 long
4621 _bfd_elf_get_reloc_upper_bound (abfd, asect)
4622      bfd *abfd ATTRIBUTE_UNUSED;
4623      sec_ptr asect;
4624 {
4625   return (asect->reloc_count + 1) * sizeof (arelent *);
4626 }
4627
4628 /* Canonicalize the relocs.  */
4629
4630 long
4631 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
4632      bfd *abfd;
4633      sec_ptr section;
4634      arelent **relptr;
4635      asymbol **symbols;
4636 {
4637   arelent *tblptr;
4638   unsigned int i;
4639
4640   if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd,
4641                                                            section,
4642                                                            symbols,
4643                                                            false))
4644     return -1;
4645
4646   tblptr = section->relocation;
4647   for (i = 0; i < section->reloc_count; i++)
4648     *relptr++ = tblptr++;
4649
4650   *relptr = NULL;
4651
4652   return section->reloc_count;
4653 }
4654
4655 long
4656 _bfd_elf_get_symtab (abfd, alocation)
4657      bfd *abfd;
4658      asymbol **alocation;
4659 {
4660   long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table
4661     (abfd, alocation, false);
4662
4663   if (symcount >= 0)
4664     bfd_get_symcount (abfd) = symcount;
4665   return symcount;
4666 }
4667
4668 long
4669 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
4670      bfd *abfd;
4671      asymbol **alocation;
4672 {
4673   return get_elf_backend_data (abfd)->s->slurp_symbol_table
4674     (abfd, alocation, true);
4675 }
4676
4677 /* Return the size required for the dynamic reloc entries.  Any
4678    section that was actually installed in the BFD, and has type
4679    SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4680    considered to be a dynamic reloc section.  */
4681
4682 long
4683 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
4684      bfd *abfd;
4685 {
4686   long ret;
4687   asection *s;
4688
4689   if (elf_dynsymtab (abfd) == 0)
4690     {
4691       bfd_set_error (bfd_error_invalid_operation);
4692       return -1;
4693     }
4694
4695   ret = sizeof (arelent *);
4696   for (s = abfd->sections; s != NULL; s = s->next)
4697     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4698         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4699             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4700       ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
4701               * sizeof (arelent *));
4702
4703   return ret;
4704 }
4705
4706 /* Canonicalize the dynamic relocation entries.  Note that we return
4707    the dynamic relocations as a single block, although they are
4708    actually associated with particular sections; the interface, which
4709    was designed for SunOS style shared libraries, expects that there
4710    is only one set of dynamic relocs.  Any section that was actually
4711    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4712    the dynamic symbol table, is considered to be a dynamic reloc
4713    section.  */
4714
4715 long
4716 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
4717      bfd *abfd;
4718      arelent **storage;
4719      asymbol **syms;
4720 {
4721   boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
4722   asection *s;
4723   long ret;
4724
4725   if (elf_dynsymtab (abfd) == 0)
4726     {
4727       bfd_set_error (bfd_error_invalid_operation);
4728       return -1;
4729     }
4730
4731   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
4732   ret = 0;
4733   for (s = abfd->sections; s != NULL; s = s->next)
4734     {
4735       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4736           && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4737               || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4738         {
4739           arelent *p;
4740           long count, i;
4741
4742           if (! (*slurp_relocs) (abfd, s, syms, true))
4743             return -1;
4744           count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
4745           p = s->relocation;
4746           for (i = 0; i < count; i++)
4747             *storage++ = p++;
4748           ret += count;
4749         }
4750     }
4751
4752   *storage = NULL;
4753
4754   return ret;
4755 }
4756 \f
4757 /* Read in the version information.  */
4758
4759 boolean
4760 _bfd_elf_slurp_version_tables (abfd)
4761      bfd *abfd;
4762 {
4763   bfd_byte *contents = NULL;
4764
4765   if (elf_dynverdef (abfd) != 0)
4766     {
4767       Elf_Internal_Shdr *hdr;
4768       Elf_External_Verdef *everdef;
4769       Elf_Internal_Verdef *iverdef;
4770       Elf_Internal_Verdef *iverdefarr;
4771       Elf_Internal_Verdef iverdefmem;
4772       unsigned int i;
4773       unsigned int maxidx;
4774
4775       hdr = &elf_tdata (abfd)->dynverdef_hdr;
4776
4777       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4778       if (contents == NULL)
4779         goto error_return;
4780       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4781           || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4782         goto error_return;
4783
4784       /* We know the number of entries in the section but not the maximum
4785          index.  Therefore we have to run through all entries and find
4786          the maximum.  */
4787       everdef = (Elf_External_Verdef *) contents;
4788       maxidx = 0;
4789       for (i = 0; i < hdr->sh_info; ++i)
4790         {
4791           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
4792
4793           if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
4794             maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
4795
4796           everdef = ((Elf_External_Verdef *)
4797                      ((bfd_byte *) everdef + iverdefmem.vd_next));
4798         }
4799
4800       elf_tdata (abfd)->verdef =
4801         ((Elf_Internal_Verdef *)
4802          bfd_zalloc (abfd, maxidx * sizeof (Elf_Internal_Verdef)));
4803       if (elf_tdata (abfd)->verdef == NULL)
4804         goto error_return;
4805
4806       elf_tdata (abfd)->cverdefs = maxidx;
4807
4808       everdef = (Elf_External_Verdef *) contents;
4809       iverdefarr = elf_tdata (abfd)->verdef;
4810       for (i = 0; i < hdr->sh_info; i++)
4811         {
4812           Elf_External_Verdaux *everdaux;
4813           Elf_Internal_Verdaux *iverdaux;
4814           unsigned int j;
4815
4816           _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
4817
4818           iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
4819           memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
4820
4821           iverdef->vd_bfd = abfd;
4822
4823           iverdef->vd_auxptr = ((Elf_Internal_Verdaux *)
4824                                 bfd_alloc (abfd,
4825                                            (iverdef->vd_cnt
4826                                             * sizeof (Elf_Internal_Verdaux))));
4827           if (iverdef->vd_auxptr == NULL)
4828             goto error_return;
4829
4830           everdaux = ((Elf_External_Verdaux *)
4831                       ((bfd_byte *) everdef + iverdef->vd_aux));
4832           iverdaux = iverdef->vd_auxptr;
4833           for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
4834             {
4835               _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
4836
4837               iverdaux->vda_nodename =
4838                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4839                                                  iverdaux->vda_name);
4840               if (iverdaux->vda_nodename == NULL)
4841                 goto error_return;
4842
4843               if (j + 1 < iverdef->vd_cnt)
4844                 iverdaux->vda_nextptr = iverdaux + 1;
4845               else
4846                 iverdaux->vda_nextptr = NULL;
4847
4848               everdaux = ((Elf_External_Verdaux *)
4849                           ((bfd_byte *) everdaux + iverdaux->vda_next));
4850             }
4851
4852           iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
4853
4854           if (i + 1 < hdr->sh_info)
4855             iverdef->vd_nextdef = iverdef + 1;
4856           else
4857             iverdef->vd_nextdef = NULL;
4858
4859           everdef = ((Elf_External_Verdef *)
4860                      ((bfd_byte *) everdef + iverdef->vd_next));
4861         }
4862
4863       free (contents);
4864       contents = NULL;
4865     }
4866
4867   if (elf_dynverref (abfd) != 0)
4868     {
4869       Elf_Internal_Shdr *hdr;
4870       Elf_External_Verneed *everneed;
4871       Elf_Internal_Verneed *iverneed;
4872       unsigned int i;
4873
4874       hdr = &elf_tdata (abfd)->dynverref_hdr;
4875
4876       elf_tdata (abfd)->verref =
4877         ((Elf_Internal_Verneed *)
4878          bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verneed)));
4879       if (elf_tdata (abfd)->verref == NULL)
4880         goto error_return;
4881
4882       elf_tdata (abfd)->cverrefs = hdr->sh_info;
4883
4884       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4885       if (contents == NULL)
4886         goto error_return;
4887       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4888           || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4889         goto error_return;
4890
4891       everneed = (Elf_External_Verneed *) contents;
4892       iverneed = elf_tdata (abfd)->verref;
4893       for (i = 0; i < hdr->sh_info; i++, iverneed++)
4894         {
4895           Elf_External_Vernaux *evernaux;
4896           Elf_Internal_Vernaux *ivernaux;
4897           unsigned int j;
4898
4899           _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
4900
4901           iverneed->vn_bfd = abfd;
4902
4903           iverneed->vn_filename =
4904             bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4905                                              iverneed->vn_file);
4906           if (iverneed->vn_filename == NULL)
4907             goto error_return;
4908
4909           iverneed->vn_auxptr =
4910             ((Elf_Internal_Vernaux *)
4911              bfd_alloc (abfd,
4912                         iverneed->vn_cnt * sizeof (Elf_Internal_Vernaux)));
4913
4914           evernaux = ((Elf_External_Vernaux *)
4915                       ((bfd_byte *) everneed + iverneed->vn_aux));
4916           ivernaux = iverneed->vn_auxptr;
4917           for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
4918             {
4919               _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
4920
4921               ivernaux->vna_nodename =
4922                 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4923                                                  ivernaux->vna_name);
4924               if (ivernaux->vna_nodename == NULL)
4925                 goto error_return;
4926
4927               if (j + 1 < iverneed->vn_cnt)
4928                 ivernaux->vna_nextptr = ivernaux + 1;
4929               else
4930                 ivernaux->vna_nextptr = NULL;
4931
4932               evernaux = ((Elf_External_Vernaux *)
4933                           ((bfd_byte *) evernaux + ivernaux->vna_next));
4934             }
4935
4936           if (i + 1 < hdr->sh_info)
4937             iverneed->vn_nextref = iverneed + 1;
4938           else
4939             iverneed->vn_nextref = NULL;
4940
4941           everneed = ((Elf_External_Verneed *)
4942                       ((bfd_byte *) everneed + iverneed->vn_next));
4943         }
4944
4945       free (contents);
4946       contents = NULL;
4947     }
4948
4949   return true;
4950
4951  error_return:
4952   if (contents == NULL)
4953     free (contents);
4954   return false;
4955 }
4956 \f
4957 asymbol *
4958 _bfd_elf_make_empty_symbol (abfd)
4959      bfd *abfd;
4960 {
4961   elf_symbol_type *newsym;
4962
4963   newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
4964   if (!newsym)
4965     return NULL;
4966   else
4967     {
4968       newsym->symbol.the_bfd = abfd;
4969       return &newsym->symbol;
4970     }
4971 }
4972
4973 void
4974 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
4975      bfd *ignore_abfd ATTRIBUTE_UNUSED;
4976      asymbol *symbol;
4977      symbol_info *ret;
4978 {
4979   bfd_symbol_info (symbol, ret);
4980 }
4981
4982 /* Return whether a symbol name implies a local symbol.  Most targets
4983    use this function for the is_local_label_name entry point, but some
4984    override it.  */
4985
4986 boolean
4987 _bfd_elf_is_local_label_name (abfd, name)
4988      bfd *abfd ATTRIBUTE_UNUSED;
4989      const char *name;
4990 {
4991   /* Normal local symbols start with ``.L''.  */
4992   if (name[0] == '.' && name[1] == 'L')
4993     return true;
4994
4995   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4996      DWARF debugging symbols starting with ``..''.  */
4997   if (name[0] == '.' && name[1] == '.')
4998     return true;
4999
5000   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5001      emitting DWARF debugging output.  I suspect this is actually a
5002      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5003      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5004      underscore to be emitted on some ELF targets).  For ease of use,
5005      we treat such symbols as local.  */
5006   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
5007     return true;
5008
5009   return false;
5010 }
5011
5012 alent *
5013 _bfd_elf_get_lineno (ignore_abfd, symbol)
5014      bfd *ignore_abfd ATTRIBUTE_UNUSED;
5015      asymbol *symbol ATTRIBUTE_UNUSED;
5016 {
5017   abort ();
5018   return NULL;
5019 }
5020
5021 boolean
5022 _bfd_elf_set_arch_mach (abfd, arch, machine)
5023      bfd *abfd;
5024      enum bfd_architecture arch;
5025      unsigned long machine;
5026 {
5027   /* If this isn't the right architecture for this backend, and this
5028      isn't the generic backend, fail.  */
5029   if (arch != get_elf_backend_data (abfd)->arch
5030       && arch != bfd_arch_unknown
5031       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
5032     return false;
5033
5034   return bfd_default_set_arch_mach (abfd, arch, machine);
5035 }
5036
5037 /* Find the function to a particular section and offset,
5038    for error reporting.  */
5039
5040 static boolean
5041 elf_find_function (abfd, section, symbols, offset,
5042                    filename_ptr, functionname_ptr)
5043      bfd *abfd ATTRIBUTE_UNUSED;
5044      asection *section;
5045      asymbol **symbols;
5046      bfd_vma offset;
5047      const char **filename_ptr;
5048      const char **functionname_ptr;
5049 {
5050   const char *filename;
5051   asymbol *func;
5052   bfd_vma low_func;
5053   asymbol **p;
5054
5055   filename = NULL;
5056   func = NULL;
5057   low_func = 0;
5058
5059   for (p = symbols; *p != NULL; p++)
5060     {
5061       elf_symbol_type *q;
5062
5063       q = (elf_symbol_type *) *p;
5064
5065       if (bfd_get_section (&q->symbol) != section)
5066         continue;
5067
5068       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5069         {
5070         default:
5071           break;
5072         case STT_FILE:
5073           filename = bfd_asymbol_name (&q->symbol);
5074           break;
5075         case STT_NOTYPE:
5076         case STT_FUNC:
5077           if (q->symbol.section == section
5078               && q->symbol.value >= low_func
5079               && q->symbol.value <= offset)
5080             {
5081               func = (asymbol *) q;
5082               low_func = q->symbol.value;
5083             }
5084           break;
5085         }
5086     }
5087
5088   if (func == NULL)
5089     return false;
5090
5091   if (filename_ptr)
5092     *filename_ptr = filename;
5093   if (functionname_ptr)
5094     *functionname_ptr = bfd_asymbol_name (func);
5095
5096   return true;
5097 }
5098
5099 /* Find the nearest line to a particular section and offset,
5100    for error reporting.  */
5101
5102 boolean
5103 _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
5104                             filename_ptr, functionname_ptr, line_ptr)
5105      bfd *abfd;
5106      asection *section;
5107      asymbol **symbols;
5108      bfd_vma offset;
5109      const char **filename_ptr;
5110      const char **functionname_ptr;
5111      unsigned int *line_ptr;
5112 {
5113   boolean found;
5114
5115   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
5116                                      filename_ptr, functionname_ptr,
5117                                      line_ptr))
5118     {
5119       if (!*functionname_ptr)
5120         elf_find_function (abfd, section, symbols, offset,
5121                            *filename_ptr ? NULL : filename_ptr,
5122                            functionname_ptr);
5123
5124       return true;
5125     }
5126
5127   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
5128                                      filename_ptr, functionname_ptr,
5129                                      line_ptr, 0,
5130                                      &elf_tdata (abfd)->dwarf2_find_line_info))
5131     {
5132       if (!*functionname_ptr)
5133         elf_find_function (abfd, section, symbols, offset,
5134                            *filename_ptr ? NULL : filename_ptr,
5135                            functionname_ptr);
5136
5137       return true;
5138     }
5139
5140   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
5141                                              &found, filename_ptr,
5142                                              functionname_ptr, line_ptr,
5143                                              &elf_tdata (abfd)->line_info))
5144     return false;
5145   if (found)
5146     return true;
5147
5148   if (symbols == NULL)
5149     return false;
5150
5151   if (! elf_find_function (abfd, section, symbols, offset,
5152                            filename_ptr, functionname_ptr))
5153     return false;
5154
5155   *line_ptr = 0;
5156   return true;
5157 }
5158
5159 int
5160 _bfd_elf_sizeof_headers (abfd, reloc)
5161      bfd *abfd;
5162      boolean reloc;
5163 {
5164   int ret;
5165
5166   ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
5167   if (! reloc)
5168     ret += get_program_header_size (abfd);
5169   return ret;
5170 }
5171
5172 boolean
5173 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
5174      bfd *abfd;
5175      sec_ptr section;
5176      PTR location;
5177      file_ptr offset;
5178      bfd_size_type count;
5179 {
5180   Elf_Internal_Shdr *hdr;
5181
5182   if (! abfd->output_has_begun
5183       && ! _bfd_elf_compute_section_file_positions
5184       (abfd, (struct bfd_link_info *) NULL))
5185     return false;
5186
5187   hdr = &elf_section_data (section)->this_hdr;
5188
5189   if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
5190     return false;
5191   if (bfd_write (location, 1, count, abfd) != count)
5192     return false;
5193
5194   return true;
5195 }
5196
5197 void
5198 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
5199      bfd *abfd ATTRIBUTE_UNUSED;
5200      arelent *cache_ptr ATTRIBUTE_UNUSED;
5201      Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
5202 {
5203   abort ();
5204 }
5205
5206 #if 0
5207 void
5208 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
5209      bfd *abfd;
5210      arelent *cache_ptr;
5211      Elf_Internal_Rel *dst;
5212 {
5213   abort ();
5214 }
5215 #endif
5216
5217 /* Try to convert a non-ELF reloc into an ELF one.  */
5218
5219 boolean
5220 _bfd_elf_validate_reloc (abfd, areloc)
5221      bfd *abfd;
5222      arelent *areloc;
5223 {
5224   /* Check whether we really have an ELF howto.  */
5225
5226   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
5227     {
5228       bfd_reloc_code_real_type code;
5229       reloc_howto_type *howto;
5230
5231       /* Alien reloc: Try to determine its type to replace it with an
5232          equivalent ELF reloc.  */
5233
5234       if (areloc->howto->pc_relative)
5235         {
5236           switch (areloc->howto->bitsize)
5237             {
5238             case 8:
5239               code = BFD_RELOC_8_PCREL;
5240               break;
5241             case 12:
5242               code = BFD_RELOC_12_PCREL;
5243               break;
5244             case 16:
5245               code = BFD_RELOC_16_PCREL;
5246               break;
5247             case 24:
5248               code = BFD_RELOC_24_PCREL;
5249               break;
5250             case 32:
5251               code = BFD_RELOC_32_PCREL;
5252               break;
5253             case 64:
5254               code = BFD_RELOC_64_PCREL;
5255               break;
5256             default:
5257               goto fail;
5258             }
5259
5260           howto = bfd_reloc_type_lookup (abfd, code);
5261
5262           if (areloc->howto->pcrel_offset != howto->pcrel_offset)
5263             {
5264               if (howto->pcrel_offset)
5265                 areloc->addend += areloc->address;
5266               else
5267                 areloc->addend -= areloc->address; /* addend is unsigned!! */
5268             }
5269         }
5270       else
5271         {
5272           switch (areloc->howto->bitsize)
5273             {
5274             case 8:
5275               code = BFD_RELOC_8;
5276               break;
5277             case 14:
5278               code = BFD_RELOC_14;
5279               break;
5280             case 16:
5281               code = BFD_RELOC_16;
5282               break;
5283             case 26:
5284               code = BFD_RELOC_26;
5285               break;
5286             case 32:
5287               code = BFD_RELOC_32;
5288               break;
5289             case 64:
5290               code = BFD_RELOC_64;
5291               break;
5292             default:
5293               goto fail;
5294             }
5295
5296           howto = bfd_reloc_type_lookup (abfd, code);
5297         }
5298
5299       if (howto)
5300         areloc->howto = howto;
5301       else
5302         goto fail;
5303     }
5304
5305   return true;
5306
5307  fail:
5308   (*_bfd_error_handler)
5309     (_("%s: unsupported relocation type %s"),
5310      bfd_get_filename (abfd), areloc->howto->name);
5311   bfd_set_error (bfd_error_bad_value);
5312   return false;
5313 }
5314
5315 boolean
5316 _bfd_elf_close_and_cleanup (abfd)
5317      bfd *abfd;
5318 {
5319   if (bfd_get_format (abfd) == bfd_object)
5320     {
5321       if (elf_shstrtab (abfd) != NULL)
5322         _bfd_stringtab_free (elf_shstrtab (abfd));
5323     }
5324
5325   return _bfd_generic_close_and_cleanup (abfd);
5326 }
5327
5328 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5329    in the relocation's offset.  Thus we cannot allow any sort of sanity
5330    range-checking to interfere.  There is nothing else to do in processing
5331    this reloc.  */
5332
5333 bfd_reloc_status_type
5334 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
5335      bfd *abfd ATTRIBUTE_UNUSED;
5336      arelent *re ATTRIBUTE_UNUSED;
5337      struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
5338      PTR data ATTRIBUTE_UNUSED;
5339      asection *is ATTRIBUTE_UNUSED;
5340      bfd *obfd ATTRIBUTE_UNUSED;
5341      char **errmsg ATTRIBUTE_UNUSED;
5342 {
5343   return bfd_reloc_ok;
5344 }
5345 \f
5346 /* Elf core file support.  Much of this only works on native
5347    toolchains, since we rely on knowing the
5348    machine-dependent procfs structure in order to pick
5349    out details about the corefile.  */
5350
5351 #ifdef HAVE_SYS_PROCFS_H
5352 # include <sys/procfs.h>
5353 #endif
5354
5355 /* FIXME: this is kinda wrong, but it's what gdb wants.  */
5356
5357 static int
5358 elfcore_make_pid (abfd)
5359      bfd *abfd;
5360 {
5361   return ((elf_tdata (abfd)->core_lwpid << 16)
5362           + (elf_tdata (abfd)->core_pid));
5363 }
5364
5365 /* If there isn't a section called NAME, make one, using
5366    data from SECT.  Note, this function will generate a
5367    reference to NAME, so you shouldn't deallocate or
5368    overwrite it.  */
5369
5370 static boolean
5371 elfcore_maybe_make_sect (abfd, name, sect)
5372      bfd *abfd;
5373      char *name;
5374      asection *sect;
5375 {
5376   asection *sect2;
5377
5378   if (bfd_get_section_by_name (abfd, name) != NULL)
5379     return true;
5380
5381   sect2 = bfd_make_section (abfd, name);
5382   if (sect2 == NULL)
5383     return false;
5384
5385   sect2->_raw_size = sect->_raw_size;
5386   sect2->filepos = sect->filepos;
5387   sect2->flags = sect->flags;
5388   sect2->alignment_power = sect->alignment_power;
5389   return true;
5390 }
5391
5392 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
5393    actually creates up to two pseudosections:
5394    - For the single-threaded case, a section named NAME, unless
5395      such a section already exists.
5396    - For the multi-threaded case, a section named "NAME/PID", where
5397      PID is elfcore_make_pid (abfd).
5398    Both pseudosections have identical contents. */
5399 boolean
5400 _bfd_elfcore_make_pseudosection (abfd, name, size, filepos)
5401      bfd *abfd;
5402      char *name;
5403      int size;
5404      int filepos;
5405 {
5406   char buf[100];
5407   char *threaded_name;
5408   asection *sect;
5409
5410   /* Build the section name.  */
5411
5412   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
5413   threaded_name = bfd_alloc (abfd, strlen (buf) + 1);
5414   if (threaded_name == NULL)
5415     return false;
5416   strcpy (threaded_name, buf);
5417
5418   sect = bfd_make_section (abfd, threaded_name);
5419   if (sect == NULL)
5420     return false;
5421   sect->_raw_size = size;
5422   sect->filepos = filepos;
5423   sect->flags = SEC_HAS_CONTENTS;
5424   sect->alignment_power = 2;
5425
5426   return elfcore_maybe_make_sect (abfd, name, sect);
5427 }
5428
5429 /* prstatus_t exists on:
5430      solaris 2.5+
5431      linux 2.[01] + glibc
5432      unixware 4.2
5433 */
5434
5435 #if defined (HAVE_PRSTATUS_T)
5436 static boolean elfcore_grok_prstatus PARAMS ((bfd *, Elf_Internal_Note *));
5437
5438 static boolean
5439 elfcore_grok_prstatus (abfd, note)
5440      bfd *abfd;
5441      Elf_Internal_Note *note;
5442 {
5443   int raw_size;
5444   int offset;
5445
5446   if (note->descsz == sizeof (prstatus_t))
5447     {
5448       prstatus_t prstat;
5449
5450       raw_size = sizeof (prstat.pr_reg);
5451       offset   = offsetof (prstatus_t, pr_reg);
5452       memcpy (&prstat, note->descdata, sizeof (prstat));
5453
5454       elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5455       elf_tdata (abfd)->core_pid = prstat.pr_pid;
5456
5457       /* pr_who exists on:
5458          solaris 2.5+
5459          unixware 4.2
5460          pr_who doesn't exist on:
5461          linux 2.[01]
5462          */
5463 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5464       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5465 #endif
5466     }
5467 #if defined (HAVE_PRSTATUS32_T)
5468   else if (note->descsz == sizeof (prstatus32_t))
5469     {
5470       /* 64-bit host, 32-bit corefile */
5471       prstatus32_t prstat;
5472
5473       raw_size = sizeof (prstat.pr_reg);
5474       offset   = offsetof (prstatus32_t, pr_reg);
5475       memcpy (&prstat, note->descdata, sizeof (prstat));
5476
5477       elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5478       elf_tdata (abfd)->core_pid = prstat.pr_pid;
5479
5480       /* pr_who exists on:
5481          solaris 2.5+
5482          unixware 4.2
5483          pr_who doesn't exist on:
5484          linux 2.[01]
5485          */
5486 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
5487       elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5488 #endif
5489     }
5490 #endif /* HAVE_PRSTATUS32_T */
5491   else
5492     {
5493       /* Fail - we don't know how to handle any other
5494          note size (ie. data object type).  */
5495       return true;
5496     }
5497
5498   /* Make a ".reg/999" section and a ".reg" section.  */
5499   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
5500                                           raw_size, note->descpos + offset);
5501 }
5502 #endif /* defined (HAVE_PRSTATUS_T) */
5503
5504 /* Create a pseudosection containing the exact contents of NOTE.  */
5505 static boolean
5506 elfcore_make_note_pseudosection (abfd, name, note)
5507      bfd *abfd;
5508      char *name;
5509      Elf_Internal_Note *note;
5510 {
5511   return _bfd_elfcore_make_pseudosection (abfd, name,
5512                                           note->descsz, note->descpos);
5513 }
5514
5515 /* There isn't a consistent prfpregset_t across platforms,
5516    but it doesn't matter, because we don't have to pick this
5517    data structure apart.  */
5518
5519 static boolean
5520 elfcore_grok_prfpreg (abfd, note)
5521      bfd *abfd;
5522      Elf_Internal_Note *note;
5523 {
5524   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
5525 }
5526
5527 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
5528    type of 5 (NT_PRXFPREG).  Just include the whole note's contents
5529    literally.  */
5530
5531 static boolean
5532 elfcore_grok_prxfpreg (abfd, note)
5533      bfd *abfd;
5534      Elf_Internal_Note *note;
5535 {
5536   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
5537 }
5538
5539 #if defined (HAVE_PRPSINFO_T)
5540 typedef prpsinfo_t   elfcore_psinfo_t;
5541 #if defined (HAVE_PRPSINFO32_T)         /* Sparc64 cross Sparc32 */
5542 typedef prpsinfo32_t elfcore_psinfo32_t;
5543 #endif
5544 #endif
5545
5546 #if defined (HAVE_PSINFO_T)
5547 typedef psinfo_t   elfcore_psinfo_t;
5548 #if defined (HAVE_PSINFO32_T)           /* Sparc64 cross Sparc32 */
5549 typedef psinfo32_t elfcore_psinfo32_t;
5550 #endif
5551 #endif
5552
5553 /* return a malloc'ed copy of a string at START which is at
5554    most MAX bytes long, possibly without a terminating '\0'.
5555    the copy will always have a terminating '\0'.  */
5556
5557 char *
5558 _bfd_elfcore_strndup (abfd, start, max)
5559      bfd *abfd;
5560      char *start;
5561      int max;
5562 {
5563   char *dup;
5564   char *end = memchr (start, '\0', max);
5565   int len;
5566
5567   if (end == NULL)
5568     len = max;
5569   else
5570     len = end - start;
5571
5572   dup = bfd_alloc (abfd, len + 1);
5573   if (dup == NULL)
5574     return NULL;
5575
5576   memcpy (dup, start, len);
5577   dup[len] = '\0';
5578
5579   return dup;
5580 }
5581
5582 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5583 static boolean elfcore_grok_psinfo PARAMS ((bfd *, Elf_Internal_Note *));
5584
5585 static boolean
5586 elfcore_grok_psinfo (abfd, note)
5587      bfd *abfd;
5588      Elf_Internal_Note *note;
5589 {
5590   if (note->descsz == sizeof (elfcore_psinfo_t))
5591     {
5592       elfcore_psinfo_t psinfo;
5593
5594       memcpy (&psinfo, note->descdata, sizeof (psinfo));
5595
5596       elf_tdata (abfd)->core_program
5597         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
5598                                 sizeof (psinfo.pr_fname));
5599
5600       elf_tdata (abfd)->core_command
5601         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
5602                                 sizeof (psinfo.pr_psargs));
5603     }
5604 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
5605   else if (note->descsz == sizeof (elfcore_psinfo32_t))
5606     {
5607       /* 64-bit host, 32-bit corefile */
5608       elfcore_psinfo32_t psinfo;
5609
5610       memcpy (&psinfo, note->descdata, sizeof (psinfo));
5611
5612       elf_tdata (abfd)->core_program
5613         = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
5614                                 sizeof (psinfo.pr_fname));
5615
5616       elf_tdata (abfd)->core_command
5617         = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
5618                                 sizeof (psinfo.pr_psargs));
5619     }
5620 #endif
5621
5622   else
5623     {
5624       /* Fail - we don't know how to handle any other
5625          note size (ie. data object type).  */
5626       return true;
5627     }
5628
5629   /* Note that for some reason, a spurious space is tacked
5630      onto the end of the args in some (at least one anyway)
5631      implementations, so strip it off if it exists.  */
5632
5633   {
5634     char *command = elf_tdata (abfd)->core_command;
5635     int n = strlen (command);
5636
5637     if (0 < n && command[n - 1] == ' ')
5638       command[n - 1] = '\0';
5639   }
5640
5641   return true;
5642 }
5643 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5644
5645 #if defined (HAVE_PSTATUS_T)
5646 static boolean
5647 elfcore_grok_pstatus (abfd, note)
5648      bfd *abfd;
5649      Elf_Internal_Note *note;
5650 {
5651   if (note->descsz == sizeof (pstatus_t)
5652 #if defined (HAVE_PXSTATUS_T)
5653       || note->descsz == sizeof (pxstatus_t)
5654 #endif
5655       )
5656     {
5657       pstatus_t pstat;
5658
5659       memcpy (&pstat, note->descdata, sizeof (pstat));
5660
5661       elf_tdata (abfd)->core_pid = pstat.pr_pid;
5662     }
5663 #if defined (HAVE_PSTATUS32_T)
5664   else if (note->descsz == sizeof (pstatus32_t))
5665     {
5666       /* 64-bit host, 32-bit corefile */
5667       pstatus32_t pstat;
5668
5669       memcpy (&pstat, note->descdata, sizeof (pstat));
5670
5671       elf_tdata (abfd)->core_pid = pstat.pr_pid;
5672     }
5673 #endif
5674   /* Could grab some more details from the "representative"
5675      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5676      NT_LWPSTATUS note, presumably.  */
5677
5678   return true;
5679 }
5680 #endif /* defined (HAVE_PSTATUS_T) */
5681
5682 #if defined (HAVE_LWPSTATUS_T)
5683 static boolean
5684 elfcore_grok_lwpstatus (abfd, note)
5685      bfd *abfd;
5686      Elf_Internal_Note *note;
5687 {
5688   lwpstatus_t lwpstat;
5689   char buf[100];
5690   char *name;
5691   asection *sect;
5692
5693   if (note->descsz != sizeof (lwpstat)
5694 #if defined (HAVE_LWPXSTATUS_T)
5695       && note->descsz != sizeof (lwpxstatus_t)
5696 #endif
5697       )
5698     return true;
5699
5700   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
5701
5702   elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
5703   elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
5704
5705   /* Make a ".reg/999" section.  */
5706
5707   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
5708   name = bfd_alloc (abfd, strlen (buf) + 1);
5709   if (name == NULL)
5710     return false;
5711   strcpy (name, buf);
5712
5713   sect = bfd_make_section (abfd, name);
5714   if (sect == NULL)
5715     return false;
5716
5717 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5718   sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
5719   sect->filepos = note->descpos
5720     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
5721 #endif
5722
5723 #if defined (HAVE_LWPSTATUS_T_PR_REG)
5724   sect->_raw_size = sizeof (lwpstat.pr_reg);
5725   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
5726 #endif
5727
5728   sect->flags = SEC_HAS_CONTENTS;
5729   sect->alignment_power = 2;
5730
5731   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
5732     return false;
5733
5734   /* Make a ".reg2/999" section */
5735
5736   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
5737   name = bfd_alloc (abfd, strlen (buf) + 1);
5738   if (name == NULL)
5739     return false;
5740   strcpy (name, buf);
5741
5742   sect = bfd_make_section (abfd, name);
5743   if (sect == NULL)
5744     return false;
5745
5746 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5747   sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
5748   sect->filepos = note->descpos
5749     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
5750 #endif
5751
5752 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5753   sect->_raw_size = sizeof (lwpstat.pr_fpreg);
5754   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
5755 #endif
5756
5757   sect->flags = SEC_HAS_CONTENTS;
5758   sect->alignment_power = 2;
5759
5760   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
5761 }
5762 #endif /* defined (HAVE_LWPSTATUS_T) */
5763
5764 #if defined (HAVE_WIN32_PSTATUS_T)
5765 static boolean
5766 elfcore_grok_win32pstatus (abfd, note)
5767      bfd *abfd;
5768      Elf_Internal_Note *note;
5769 {
5770   char buf[30];
5771   char *name;
5772   asection *sect;
5773   win32_pstatus_t pstatus;
5774
5775   if (note->descsz < sizeof (pstatus))
5776     return true;
5777
5778   memcpy (&pstatus, note->descdata, note->descsz);
5779
5780   switch (pstatus.data_type)
5781     {
5782     case NOTE_INFO_PROCESS:
5783       /* FIXME: need to add ->core_command.  */
5784       elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
5785       elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
5786       break;
5787
5788     case NOTE_INFO_THREAD:
5789       /* Make a ".reg/999" section.  */
5790       sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
5791
5792       name = bfd_alloc (abfd, strlen (buf) + 1);
5793       if (name == NULL)
5794         return false;
5795
5796       strcpy (name, buf);
5797
5798       sect = bfd_make_section (abfd, name);
5799       if (sect == NULL)
5800         return false;
5801
5802       sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
5803       sect->filepos = note->descpos + offsetof (struct win32_pstatus,
5804                                                 data.thread_info.thread_context);
5805       sect->flags = SEC_HAS_CONTENTS;
5806       sect->alignment_power = 2;
5807
5808       if (pstatus.data.thread_info.is_active_thread)
5809         if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
5810           return false;
5811       break;
5812
5813     case NOTE_INFO_MODULE:
5814       /* Make a ".module/xxxxxxxx" section.  */
5815       sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
5816
5817       name = bfd_alloc (abfd, strlen (buf) + 1);
5818       if (name == NULL)
5819         return false;
5820
5821       strcpy (name, buf);
5822
5823       sect = bfd_make_section (abfd, name);
5824
5825       if (sect == NULL)
5826         return false;
5827
5828       sect->_raw_size = note->descsz;
5829       sect->filepos = note->descpos;
5830       sect->flags = SEC_HAS_CONTENTS;
5831       sect->alignment_power = 2;
5832       break;
5833
5834     default:
5835       return true;
5836     }
5837
5838   return true;
5839 }
5840 #endif /* HAVE_WIN32_PSTATUS_T */
5841
5842 static boolean
5843 elfcore_grok_note (abfd, note)
5844      bfd *abfd;
5845      Elf_Internal_Note *note;
5846 {
5847   struct elf_backend_data *bed = get_elf_backend_data (abfd);
5848
5849   switch (note->type)
5850     {
5851     default:
5852       return true;
5853
5854     case NT_PRSTATUS:
5855       if (bed->elf_backend_grok_prstatus)
5856         if ((*bed->elf_backend_grok_prstatus) (abfd, note))
5857           return true;
5858 #if defined (HAVE_PRSTATUS_T)
5859       return elfcore_grok_prstatus (abfd, note);
5860 #else
5861       return true;
5862 #endif
5863
5864 #if defined (HAVE_PSTATUS_T)
5865     case NT_PSTATUS:
5866       return elfcore_grok_pstatus (abfd, note);
5867 #endif
5868
5869 #if defined (HAVE_LWPSTATUS_T)
5870     case NT_LWPSTATUS:
5871       return elfcore_grok_lwpstatus (abfd, note);
5872 #endif
5873
5874     case NT_FPREGSET:           /* FIXME: rename to NT_PRFPREG */
5875       return elfcore_grok_prfpreg (abfd, note);
5876
5877 #if defined (HAVE_WIN32_PSTATUS_T)
5878     case NT_WIN32PSTATUS:
5879       return elfcore_grok_win32pstatus (abfd, note);
5880 #endif
5881
5882     case NT_PRXFPREG:           /* Linux SSE extension */
5883       if (note->namesz == 5
5884           && ! strcmp (note->namedata, "LINUX"))
5885         return elfcore_grok_prxfpreg (abfd, note);
5886       else
5887         return true;
5888
5889     case NT_PRPSINFO:
5890     case NT_PSINFO:
5891       if (bed->elf_backend_grok_psinfo)
5892         if ((*bed->elf_backend_grok_psinfo) (abfd, note))
5893           return true;
5894 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5895       return elfcore_grok_psinfo (abfd, note);
5896 #else
5897       return true;
5898 #endif
5899     }
5900 }
5901
5902 static boolean
5903 elfcore_read_notes (abfd, offset, size)
5904      bfd *abfd;
5905      bfd_vma offset;
5906      bfd_vma size;
5907 {
5908   char *buf;
5909   char *p;
5910
5911   if (size <= 0)
5912     return true;
5913
5914   if (bfd_seek (abfd, offset, SEEK_SET) == -1)
5915     return false;
5916
5917   buf = bfd_malloc ((size_t) size);
5918   if (buf == NULL)
5919     return false;
5920
5921   if (bfd_read (buf, size, 1, abfd) != size)
5922     {
5923     error:
5924       free (buf);
5925       return false;
5926     }
5927
5928   p = buf;
5929   while (p < buf + size)
5930     {
5931       /* FIXME: bad alignment assumption.  */
5932       Elf_External_Note *xnp = (Elf_External_Note *) p;
5933       Elf_Internal_Note in;
5934
5935       in.type = bfd_h_get_32 (abfd, (bfd_byte *) xnp->type);
5936
5937       in.namesz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->namesz);
5938       in.namedata = xnp->name;
5939
5940       in.descsz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->descsz);
5941       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
5942       in.descpos = offset + (in.descdata - buf);
5943
5944       if (! elfcore_grok_note (abfd, &in))
5945         goto error;
5946
5947       p = in.descdata + BFD_ALIGN (in.descsz, 4);
5948     }
5949
5950   free (buf);
5951   return true;
5952 }
5953 \f
5954 /* Providing external access to the ELF program header table.  */
5955
5956 /* Return an upper bound on the number of bytes required to store a
5957    copy of ABFD's program header table entries.  Return -1 if an error
5958    occurs; bfd_get_error will return an appropriate code.  */
5959
5960 long
5961 bfd_get_elf_phdr_upper_bound (abfd)
5962      bfd *abfd;
5963 {
5964   if (abfd->xvec->flavour != bfd_target_elf_flavour)
5965     {
5966       bfd_set_error (bfd_error_wrong_format);
5967       return -1;
5968     }
5969
5970   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
5971 }
5972
5973 /* Copy ABFD's program header table entries to *PHDRS.  The entries
5974    will be stored as an array of Elf_Internal_Phdr structures, as
5975    defined in include/elf/internal.h.  To find out how large the
5976    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
5977
5978    Return the number of program header table entries read, or -1 if an
5979    error occurs; bfd_get_error will return an appropriate code.  */
5980
5981 int
5982 bfd_get_elf_phdrs (abfd, phdrs)
5983      bfd *abfd;
5984      void *phdrs;
5985 {
5986   int num_phdrs;
5987
5988   if (abfd->xvec->flavour != bfd_target_elf_flavour)
5989     {
5990       bfd_set_error (bfd_error_wrong_format);
5991       return -1;
5992     }
5993
5994   num_phdrs = elf_elfheader (abfd)->e_phnum;
5995   memcpy (phdrs, elf_tdata (abfd)->phdr,
5996           num_phdrs * sizeof (Elf_Internal_Phdr));
5997
5998   return num_phdrs;
5999 }
6000
6001 void
6002 _bfd_elf_sprintf_vma (abfd, buf, value)
6003      bfd *abfd ATTRIBUTE_UNUSED;
6004      char *buf;
6005      bfd_vma value;
6006 {
6007 #ifdef BFD64
6008   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
6009
6010   i_ehdrp = elf_elfheader (abfd);
6011   if (i_ehdrp == NULL)
6012     sprintf_vma (buf, value);
6013   else
6014     {
6015       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
6016         {
6017 #if BFD_HOST_64BIT_LONG
6018           sprintf (buf, "%016lx", value);
6019 #else
6020           sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
6021                    _bfd_int64_low (value));
6022 #endif
6023         }
6024       else
6025         sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
6026     }
6027 #else
6028   sprintf_vma (buf, value);
6029 #endif
6030 }
6031
6032 void
6033 _bfd_elf_fprintf_vma (abfd, stream, value)
6034      bfd *abfd ATTRIBUTE_UNUSED;
6035      PTR stream;
6036      bfd_vma value;
6037 {
6038 #ifdef BFD64
6039   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
6040
6041   i_ehdrp = elf_elfheader (abfd);
6042   if (i_ehdrp == NULL)
6043     fprintf_vma ((FILE *) stream, value);
6044   else
6045     {
6046       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
6047         {
6048 #if BFD_HOST_64BIT_LONG
6049           fprintf ((FILE *) stream, "%016lx", value);
6050 #else
6051           fprintf ((FILE *) stream, "%08lx%08lx",
6052                    _bfd_int64_high (value), _bfd_int64_low (value));
6053 #endif
6054         }
6055       else
6056         fprintf ((FILE *) stream, "%08lx",
6057                  (unsigned long) (value & 0xffffffff));
6058     }
6059 #else
6060   fprintf_vma ((FILE *) stream, value);
6061 #endif
6062 }
6063
6064 enum elf_reloc_type_class
6065 _bfd_elf_reloc_type_class (type)
6066      int type;
6067 {
6068   return reloc_class_normal;
6069 }