bfd/elfcode.h

   1 /* ELF executable support for BFD.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003 Free Software Foundation, Inc.
   4
   5    Written by Fred Fish @ Cygnus Support, from information published
   6    in "UNIX System V Release 4, Programmers Guide: ANSI C and
   7    Programming Support Tools".  Sufficient support for gdb.
   8
   9    Rewritten by Mark Eichin @ Cygnus Support, from information
  10    published in "System V Application Binary Interface", chapters 4
  11    and 5, as well as the various "Processor Supplement" documents
  12    derived from it. Added support for assembler and other object file
  13    utilities.  Further work done by Ken Raeburn (Cygnus Support), Michael
  14    Meissner (Open Software Foundation), and Peter Hoogenboom (University
  15    of Utah) to finish and extend this.
  16
  17 This file is part of BFD, the Binary File Descriptor library.
  18
  19 This program is free software; you can redistribute it and/or modify
  20 it under the terms of the GNU General Public License as published by
  21 the Free Software Foundation; either version 2 of the License, or
  22 (at your option) any later version.
  23
  24 This program is distributed in the hope that it will be useful,
  25 but WITHOUT ANY WARRANTY; without even the implied warranty of
  26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27 GNU General Public License for more details.
  28
  29 You should have received a copy of the GNU General Public License
  30 along with this program; if not, write to the Free Software
  31 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  32
  33 /* Problems and other issues to resolve.
  34
  35    (1)  BFD expects there to be some fixed number of "sections" in
  36         the object file.  I.E. there is a "section_count" variable in the
  37         bfd structure which contains the number of sections.  However, ELF
  38         supports multiple "views" of a file.  In particular, with current
  39         implementations, executable files typically have two tables, a
  40         program header table and a section header table, both of which
  41         partition the executable.
  42
  43         In ELF-speak, the "linking view" of the file uses the section header
  44         table to access "sections" within the file, and the "execution view"
  45         uses the program header table to access "segments" within the file.
  46         "Segments" typically may contain all the data from one or more
  47         "sections".
  48
  49         Note that the section header table is optional in ELF executables,
  50         but it is this information that is most useful to gdb.  If the
  51         section header table is missing, then gdb should probably try
  52         to make do with the program header table.  (FIXME)
  53
  54    (2)  The code in this file is compiled twice, once in 32-bit mode and
  55         once in 64-bit mode.  More of it should be made size-independent
  56         and moved into elf.c.
  57
  58    (3)  ELF section symbols are handled rather sloppily now.  This should
  59         be cleaned up, and ELF section symbols reconciled with BFD section
  60         symbols.
  61
  62    (4)  We need a published spec for 64-bit ELF.  We've got some stuff here
  63         that we're using for SPARC V9 64-bit chips, but don't assume that
  64         it's cast in stone.
  65  */
  66
  67 #include "bfd.h"
  68 #include "sysdep.h"
  69 #include "libiberty.h"
  70 #include "bfdlink.h"
  71 #include "libbfd.h"
  72 #include "elf-bfd.h"
  73
  74 /* Renaming structures, typedefs, macros and functions to be size-specific.  */
  75 #define Elf_External_Ehdr       NAME(Elf,External_Ehdr)
  76 #define Elf_External_Sym        NAME(Elf,External_Sym)
  77 #define Elf_External_Shdr       NAME(Elf,External_Shdr)
  78 #define Elf_External_Phdr       NAME(Elf,External_Phdr)
  79 #define Elf_External_Rel        NAME(Elf,External_Rel)
  80 #define Elf_External_Rela       NAME(Elf,External_Rela)
  81 #define Elf_External_Dyn        NAME(Elf,External_Dyn)
  82
  83 #define elf_core_file_failing_command   NAME(bfd_elf,core_file_failing_command)
  84 #define elf_core_file_failing_signal    NAME(bfd_elf,core_file_failing_signal)
  85 #define elf_core_file_matches_executable_p \
  86   NAME(bfd_elf,core_file_matches_executable_p)
  87 #define elf_object_p                    NAME(bfd_elf,object_p)
  88 #define elf_core_file_p                 NAME(bfd_elf,core_file_p)
  89 #define elf_get_symtab_upper_bound      NAME(bfd_elf,get_symtab_upper_bound)
  90 #define elf_get_dynamic_symtab_upper_bound \
  91   NAME(bfd_elf,get_dynamic_symtab_upper_bound)
  92 #define elf_swap_reloc_in               NAME(bfd_elf,swap_reloc_in)
  93 #define elf_swap_reloca_in              NAME(bfd_elf,swap_reloca_in)
  94 #define elf_swap_reloc_out              NAME(bfd_elf,swap_reloc_out)
  95 #define elf_swap_reloca_out             NAME(bfd_elf,swap_reloca_out)
  96 #define elf_swap_symbol_in              NAME(bfd_elf,swap_symbol_in)
  97 #define elf_swap_symbol_out             NAME(bfd_elf,swap_symbol_out)
  98 #define elf_swap_phdr_in                NAME(bfd_elf,swap_phdr_in)
  99 #define elf_swap_phdr_out               NAME(bfd_elf,swap_phdr_out)
 100 #define elf_swap_dyn_in                 NAME(bfd_elf,swap_dyn_in)
 101 #define elf_swap_dyn_out                NAME(bfd_elf,swap_dyn_out)
 102 #define elf_get_reloc_upper_bound       NAME(bfd_elf,get_reloc_upper_bound)
 103 #define elf_canonicalize_reloc          NAME(bfd_elf,canonicalize_reloc)
 104 #define elf_slurp_symbol_table          NAME(bfd_elf,slurp_symbol_table)
 105 #define elf_canonicalize_symtab         NAME(bfd_elf,canonicalize_symtab)
 106 #define elf_canonicalize_dynamic_symtab \
 107   NAME(bfd_elf,canonicalize_dynamic_symtab)
 108 #define elf_make_empty_symbol           NAME(bfd_elf,make_empty_symbol)
 109 #define elf_get_symbol_info             NAME(bfd_elf,get_symbol_info)
 110 #define elf_get_lineno                  NAME(bfd_elf,get_lineno)
 111 #define elf_set_arch_mach               NAME(bfd_elf,set_arch_mach)
 112 #define elf_find_nearest_line           NAME(bfd_elf,find_nearest_line)
 113 #define elf_sizeof_headers              NAME(bfd_elf,sizeof_headers)
 114 #define elf_set_section_contents        NAME(bfd_elf,set_section_contents)
 115 #define elf_no_info_to_howto            NAME(bfd_elf,no_info_to_howto)
 116 #define elf_no_info_to_howto_rel        NAME(bfd_elf,no_info_to_howto_rel)
 117 #define elf_find_section                NAME(bfd_elf,find_section)
 118 #define elf_write_shdrs_and_ehdr        NAME(bfd_elf,write_shdrs_and_ehdr)
 119 #define elf_write_out_phdrs             NAME(bfd_elf,write_out_phdrs)
 120 #define elf_write_relocs                NAME(bfd_elf,write_relocs)
 121 #define elf_slurp_reloc_table           NAME(bfd_elf,slurp_reloc_table)
 122 #define elf_bfd_discard_info            NAME(bfd_elf,discard_info)
 123 #define elf_reloc_symbol_deleted_p      NAME(_bfd_elf,reloc_symbol_deleted_p)
 124 #define elf_link_record_dynamic_symbol  _bfd_elf_link_record_dynamic_symbol
 125 #define elf_bfd_final_link              NAME(bfd_elf,bfd_final_link)
 126 #define elf_gc_sections                 NAME(_bfd_elf,gc_sections)
 127 #define elf_gc_common_finalize_got_offsets \
 128   NAME(_bfd_elf,gc_common_finalize_got_offsets)
 129 #define elf_gc_common_final_link        NAME(_bfd_elf,gc_common_final_link)
 130 #define elf_gc_record_vtinherit         NAME(_bfd_elf,gc_record_vtinherit)
 131 #define elf_gc_record_vtentry           NAME(_bfd_elf,gc_record_vtentry)
 132 #define elf_link_record_local_dynamic_symbol \
 133   NAME(_bfd_elf,link_record_local_dynamic_symbol)
 134
 135 #if ARCH_SIZE == 64
 136 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
 137 #define ELF_R_SYM(X)    ELF64_R_SYM(X)
 138 #define ELF_R_TYPE(X)   ELF64_R_TYPE(X)
 139 #define ELFCLASS        ELFCLASS64
 140 #define FILE_ALIGN      8
 141 #define LOG_FILE_ALIGN  3
 142 #endif
 143 #if ARCH_SIZE == 32
 144 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
 145 #define ELF_R_SYM(X)    ELF32_R_SYM(X)
 146 #define ELF_R_TYPE(X)   ELF32_R_TYPE(X)
 147 #define ELFCLASS        ELFCLASS32
 148 #define FILE_ALIGN      4
 149 #define LOG_FILE_ALIGN  2
 150 #endif
 151
 152 #ifdef DEBUG
 153 static void elf_debug_section (int, Elf_Internal_Shdr *);
 154 static void elf_debug_file (Elf_Internal_Ehdr *);
 155 static char *elf_symbol_flags (flagword);
 156 #endif
 157 \f
 158 /* Structure swapping routines */
 159
 160 /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
 161    can be handled by explicitly specifying 32 bits or "the long type".  */
 162 #if ARCH_SIZE == 64
 163 #define H_PUT_WORD              H_PUT_64
 164 #define H_PUT_SIGNED_WORD       H_PUT_S64
 165 #define H_GET_WORD              H_GET_64
 166 #define H_GET_SIGNED_WORD       H_GET_S64
 167 #endif
 168 #if ARCH_SIZE == 32
 169 #define H_PUT_WORD              H_PUT_32
 170 #define H_PUT_SIGNED_WORD       H_PUT_S32
 171 #define H_GET_WORD              H_GET_32
 172 #define H_GET_SIGNED_WORD       H_GET_S32
 173 #endif
 174
 175 /* Translate an ELF symbol in external format into an ELF symbol in internal
 176    format.  */
 177
 178 void
 179 elf_swap_symbol_in (bfd *abfd,
 180                     const void *psrc,
 181                     const void *pshn,
 182                     Elf_Internal_Sym *dst)
 183 {
 184   const Elf_External_Sym *src = psrc;
 185   const Elf_External_Sym_Shndx *shndx = pshn;
 186   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 187
 188   dst->st_name = H_GET_32 (abfd, src->st_name);
 189   if (signed_vma)
 190     dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value);
 191   else
 192     dst->st_value = H_GET_WORD (abfd, src->st_value);
 193   dst->st_size = H_GET_WORD (abfd, src->st_size);
 194   dst->st_info = H_GET_8 (abfd, src->st_info);
 195   dst->st_other = H_GET_8 (abfd, src->st_other);
 196   dst->st_shndx = H_GET_16 (abfd, src->st_shndx);
 197   if (dst->st_shndx == SHN_XINDEX)
 198     {
 199       if (shndx == NULL)
 200         abort ();
 201       dst->st_shndx = H_GET_32 (abfd, shndx->est_shndx);
 202     }
 203 }
 204
 205 /* Translate an ELF symbol in internal format into an ELF symbol in external
 206    format.  */
 207
 208 void
 209 elf_swap_symbol_out (bfd *abfd,
 210                      const Elf_Internal_Sym *src,
 211                      void *cdst,
 212                      void *shndx)
 213 {
 214   unsigned int tmp;
 215   Elf_External_Sym *dst = cdst;
 216   H_PUT_32 (abfd, src->st_name, dst->st_name);
 217   H_PUT_WORD (abfd, src->st_value, dst->st_value);
 218   H_PUT_WORD (abfd, src->st_size, dst->st_size);
 219   H_PUT_8 (abfd, src->st_info, dst->st_info);
 220   H_PUT_8 (abfd, src->st_other, dst->st_other);
 221   tmp = src->st_shndx;
 222   if (tmp > SHN_HIRESERVE)
 223     {
 224       if (shndx == NULL)
 225         abort ();
 226       H_PUT_32 (abfd, tmp, shndx);
 227       tmp = SHN_XINDEX;
 228     }
 229   H_PUT_16 (abfd, tmp, dst->st_shndx);
 230 }
 231
 232 /* Translate an ELF file header in external format into an ELF file header in
 233    internal format.  */
 234
 235 static void
 236 elf_swap_ehdr_in (bfd *abfd,
 237                   const Elf_External_Ehdr *src,
 238                   Elf_Internal_Ehdr *dst)
 239 {
 240   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 241   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 242   dst->e_type = H_GET_16 (abfd, src->e_type);
 243   dst->e_machine = H_GET_16 (abfd, src->e_machine);
 244   dst->e_version = H_GET_32 (abfd, src->e_version);
 245   if (signed_vma)
 246     dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry);
 247   else
 248     dst->e_entry = H_GET_WORD (abfd, src->e_entry);
 249   dst->e_phoff = H_GET_WORD (abfd, src->e_phoff);
 250   dst->e_shoff = H_GET_WORD (abfd, src->e_shoff);
 251   dst->e_flags = H_GET_32 (abfd, src->e_flags);
 252   dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize);
 253   dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize);
 254   dst->e_phnum = H_GET_16 (abfd, src->e_phnum);
 255   dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize);
 256   dst->e_shnum = H_GET_16 (abfd, src->e_shnum);
 257   dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx);
 258 }
 259
 260 /* Translate an ELF file header in internal format into an ELF file header in
 261    external format.  */
 262
 263 static void
 264 elf_swap_ehdr_out (bfd *abfd,
 265                    const Elf_Internal_Ehdr *src,
 266                    Elf_External_Ehdr *dst)
 267 {
 268   unsigned int tmp;
 269   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 270   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
 271   /* note that all elements of dst are *arrays of unsigned char* already...  */
 272   H_PUT_16 (abfd, src->e_type, dst->e_type);
 273   H_PUT_16 (abfd, src->e_machine, dst->e_machine);
 274   H_PUT_32 (abfd, src->e_version, dst->e_version);
 275   if (signed_vma)
 276     H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry);
 277   else
 278     H_PUT_WORD (abfd, src->e_entry, dst->e_entry);
 279   H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff);
 280   H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff);
 281   H_PUT_32 (abfd, src->e_flags, dst->e_flags);
 282   H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize);
 283   H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize);
 284   H_PUT_16 (abfd, src->e_phnum, dst->e_phnum);
 285   H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize);
 286   tmp = src->e_shnum;
 287   if (tmp >= SHN_LORESERVE)
 288     tmp = SHN_UNDEF;
 289   H_PUT_16 (abfd, tmp, dst->e_shnum);
 290   tmp = src->e_shstrndx;
 291   if (tmp >= SHN_LORESERVE)
 292     tmp = SHN_XINDEX;
 293   H_PUT_16 (abfd, tmp, dst->e_shstrndx);
 294 }
 295
 296 /* Translate an ELF section header table entry in external format into an
 297    ELF section header table entry in internal format.  */
 298
 299 static void
 300 elf_swap_shdr_in (bfd *abfd,
 301                   const Elf_External_Shdr *src,
 302                   Elf_Internal_Shdr *dst)
 303 {
 304   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 305
 306   dst->sh_name = H_GET_32 (abfd, src->sh_name);
 307   dst->sh_type = H_GET_32 (abfd, src->sh_type);
 308   dst->sh_flags = H_GET_WORD (abfd, src->sh_flags);
 309   if (signed_vma)
 310     dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr);
 311   else
 312     dst->sh_addr = H_GET_WORD (abfd, src->sh_addr);
 313   dst->sh_offset = H_GET_WORD (abfd, src->sh_offset);
 314   dst->sh_size = H_GET_WORD (abfd, src->sh_size);
 315   dst->sh_link = H_GET_32 (abfd, src->sh_link);
 316   dst->sh_info = H_GET_32 (abfd, src->sh_info);
 317   dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign);
 318   dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize);
 319   dst->bfd_section = NULL;
 320   dst->contents = NULL;
 321 }
 322
 323 /* Translate an ELF section header table entry in internal format into an
 324    ELF section header table entry in external format.  */
 325
 326 static void
 327 elf_swap_shdr_out (bfd *abfd,
 328                    const Elf_Internal_Shdr *src,
 329                    Elf_External_Shdr *dst)
 330 {
 331   /* note that all elements of dst are *arrays of unsigned char* already...  */
 332   H_PUT_32 (abfd, src->sh_name, dst->sh_name);
 333   H_PUT_32 (abfd, src->sh_type, dst->sh_type);
 334   H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags);
 335   H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr);
 336   H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset);
 337   H_PUT_WORD (abfd, src->sh_size, dst->sh_size);
 338   H_PUT_32 (abfd, src->sh_link, dst->sh_link);
 339   H_PUT_32 (abfd, src->sh_info, dst->sh_info);
 340   H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign);
 341   H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize);
 342 }
 343
 344 /* Translate an ELF program header table entry in external format into an
 345    ELF program header table entry in internal format.  */
 346
 347 void
 348 elf_swap_phdr_in (bfd *abfd,
 349                   const Elf_External_Phdr *src,
 350                   Elf_Internal_Phdr *dst)
 351 {
 352   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 353
 354   dst->p_type = H_GET_32 (abfd, src->p_type);
 355   dst->p_flags = H_GET_32 (abfd, src->p_flags);
 356   dst->p_offset = H_GET_WORD (abfd, src->p_offset);
 357   if (signed_vma)
 358     {
 359       dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr);
 360       dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr);
 361     }
 362   else
 363     {
 364       dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr);
 365       dst->p_paddr = H_GET_WORD (abfd, src->p_paddr);
 366     }
 367   dst->p_filesz = H_GET_WORD (abfd, src->p_filesz);
 368   dst->p_memsz = H_GET_WORD (abfd, src->p_memsz);
 369   dst->p_align = H_GET_WORD (abfd, src->p_align);
 370 }
 371
 372 void
 373 elf_swap_phdr_out (bfd *abfd,
 374                    const Elf_Internal_Phdr *src,
 375                    Elf_External_Phdr *dst)
 376 {
 377   /* note that all elements of dst are *arrays of unsigned char* already...  */
 378   H_PUT_32 (abfd, src->p_type, dst->p_type);
 379   H_PUT_WORD (abfd, src->p_offset, dst->p_offset);
 380   H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr);
 381   H_PUT_WORD (abfd, src->p_paddr, dst->p_paddr);
 382   H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz);
 383   H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz);
 384   H_PUT_32 (abfd, src->p_flags, dst->p_flags);
 385   H_PUT_WORD (abfd, src->p_align, dst->p_align);
 386 }
 387
 388 /* Translate an ELF reloc from external format to internal format.  */
 389 void
 390 elf_swap_reloc_in (bfd *abfd,
 391                    const bfd_byte *s,
 392                    Elf_Internal_Rela *dst)
 393 {
 394   const Elf_External_Rel *src = (const Elf_External_Rel *) s;
 395   dst->r_offset = H_GET_WORD (abfd, src->r_offset);
 396   dst->r_info = H_GET_WORD (abfd, src->r_info);
 397   dst->r_addend = 0;
 398 }
 399
 400 void
 401 elf_swap_reloca_in (bfd *abfd,
 402                     const bfd_byte *s,
 403                     Elf_Internal_Rela *dst)
 404 {
 405   const Elf_External_Rela *src = (const Elf_External_Rela *) s;
 406   dst->r_offset = H_GET_WORD (abfd, src->r_offset);
 407   dst->r_info = H_GET_WORD (abfd, src->r_info);
 408   dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
 409 }
 410
 411 /* Translate an ELF reloc from internal format to external format.  */
 412 void
 413 elf_swap_reloc_out (bfd *abfd,
 414                     const Elf_Internal_Rela *src,
 415                     bfd_byte *d)
 416 {
 417   Elf_External_Rel *dst = (Elf_External_Rel *) d;
 418   H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
 419   H_PUT_WORD (abfd, src->r_info, dst->r_info);
 420 }
 421
 422 void
 423 elf_swap_reloca_out (bfd *abfd,
 424                      const Elf_Internal_Rela *src,
 425                      bfd_byte *d)
 426 {
 427   Elf_External_Rela *dst = (Elf_External_Rela *) d;
 428   H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
 429   H_PUT_WORD (abfd, src->r_info, dst->r_info);
 430   H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
 431 }
 432
 433 void
 434 elf_swap_dyn_in (bfd *abfd,
 435                  const void *p,
 436                  Elf_Internal_Dyn *dst)
 437 {
 438   const Elf_External_Dyn *src = p;
 439
 440   dst->d_tag = H_GET_WORD (abfd, src->d_tag);
 441   dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
 442 }
 443
 444 void
 445 elf_swap_dyn_out (bfd *abfd,
 446                   const Elf_Internal_Dyn *src,
 447                   void *p)
 448 {
 449   Elf_External_Dyn *dst = p;
 450
 451   H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
 452   H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
 453 }
 454 \f
 455 /* ELF .o/exec file reading */
 456
 457 /* Begin processing a given object.
 458
 459    First we validate the file by reading in the ELF header and checking
 460    the magic number.  */
 461
 462 static inline bfd_boolean
 463 elf_file_p (Elf_External_Ehdr *x_ehdrp)
 464 {
 465   return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
 466           && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
 467           && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
 468           && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
 469 }
 470
 471 /* Check to see if the file associated with ABFD matches the target vector
 472    that ABFD points to.
 473
 474    Note that we may be called several times with the same ABFD, but different
 475    target vectors, most of which will not match.  We have to avoid leaving
 476    any side effects in ABFD, or any data it points to (like tdata), if the
 477    file does not match the target vector.  */
 478
 479 const bfd_target *
 480 elf_object_p (bfd *abfd)
 481 {
 482   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 483   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 484   Elf_External_Shdr x_shdr;     /* Section header table entry, external form */
 485   Elf_Internal_Shdr i_shdr;
 486   Elf_Internal_Shdr *i_shdrp;   /* Section header table, internal form */
 487   unsigned int shindex;
 488   char *shstrtab;               /* Internal copy of section header stringtab */
 489   const struct elf_backend_data *ebd;
 490   struct bfd_preserve preserve;
 491   asection *s;
 492   bfd_size_type amt;
 493
 494   preserve.marker = NULL;
 495
 496   /* Read in the ELF header in external format.  */
 497
 498   if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
 499     {
 500       if (bfd_get_error () != bfd_error_system_call)
 501         goto got_wrong_format_error;
 502       else
 503         goto got_no_match;
 504     }
 505
 506   /* Now check to see if we have a valid ELF file, and one that BFD can
 507      make use of.  The magic number must match, the address size ('class')
 508      and byte-swapping must match our XVEC entry, and it must have a
 509      section header table (FIXME: See comments re sections at top of this
 510      file).  */
 511
 512   if (! elf_file_p (&x_ehdr)
 513       || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
 514       || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
 515     goto got_wrong_format_error;
 516
 517   /* Check that file's byte order matches xvec's */
 518   switch (x_ehdr.e_ident[EI_DATA])
 519     {
 520     case ELFDATA2MSB:           /* Big-endian */
 521       if (! bfd_header_big_endian (abfd))
 522         goto got_wrong_format_error;
 523       break;
 524     case ELFDATA2LSB:           /* Little-endian */
 525       if (! bfd_header_little_endian (abfd))
 526         goto got_wrong_format_error;
 527       break;
 528     case ELFDATANONE:           /* No data encoding specified */
 529     default:                    /* Unknown data encoding specified */
 530       goto got_wrong_format_error;
 531     }
 532
 533   if (!bfd_preserve_save (abfd, &preserve))
 534     goto got_no_match;
 535
 536   /* Allocate an instance of the elf_obj_tdata structure and hook it up to
 537      the tdata pointer in the bfd.  */
 538
 539   if (! (*abfd->xvec->_bfd_set_format[bfd_object]) (abfd))
 540     goto got_no_match;
 541   preserve.marker = elf_tdata (abfd);
 542
 543   /* Now that we know the byte order, swap in the rest of the header */
 544   i_ehdrp = elf_elfheader (abfd);
 545   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 546 #if DEBUG & 1
 547   elf_debug_file (i_ehdrp);
 548 #endif
 549
 550   /* Reject ET_CORE (header indicates core file, not object file) */
 551   if (i_ehdrp->e_type == ET_CORE)
 552     goto got_wrong_format_error;
 553
 554   /* If this is a relocatable file and there is no section header
 555      table, then we're hosed.  */
 556   if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
 557     goto got_wrong_format_error;
 558
 559   /* As a simple sanity check, verify that the what BFD thinks is the
 560      size of each section header table entry actually matches the size
 561      recorded in the file, but only if there are any sections.  */
 562   if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
 563     goto got_wrong_format_error;
 564
 565   /* Further sanity check.  */
 566   if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
 567     goto got_wrong_format_error;
 568
 569   ebd = get_elf_backend_data (abfd);
 570
 571   /* Check that the ELF e_machine field matches what this particular
 572      BFD format expects.  */
 573   if (ebd->elf_machine_code != i_ehdrp->e_machine
 574       && (ebd->elf_machine_alt1 == 0
 575           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 576       && (ebd->elf_machine_alt2 == 0
 577           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 578     {
 579       const bfd_target * const *target_ptr;
 580
 581       if (ebd->elf_machine_code != EM_NONE)
 582         goto got_wrong_format_error;
 583
 584       /* This is the generic ELF target.  Let it match any ELF target
 585          for which we do not have a specific backend.  */
 586       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 587         {
 588           const struct elf_backend_data *back;
 589
 590           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 591             continue;
 592           back = (const struct elf_backend_data *) (*target_ptr)->backend_data;
 593           if (back->elf_machine_code == i_ehdrp->e_machine
 594               || (back->elf_machine_alt1 != 0
 595                   && back->elf_machine_alt1 == i_ehdrp->e_machine)
 596               || (back->elf_machine_alt2 != 0
 597                   && back->elf_machine_alt2 == i_ehdrp->e_machine))
 598             {
 599               /* target_ptr is an ELF backend which matches this
 600                  object file, so reject the generic ELF target.  */
 601               goto got_wrong_format_error;
 602             }
 603         }
 604     }
 605
 606   if (i_ehdrp->e_type == ET_EXEC)
 607     abfd->flags |= EXEC_P;
 608   else if (i_ehdrp->e_type == ET_DYN)
 609     abfd->flags |= DYNAMIC;
 610
 611   if (i_ehdrp->e_phnum > 0)
 612     abfd->flags |= D_PAGED;
 613
 614   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 615     {
 616       /* It's OK if this fails for the generic target.  */
 617       if (ebd->elf_machine_code != EM_NONE)
 618         goto got_no_match;
 619     }
 620
 621   /* Remember the entry point specified in the ELF file header.  */
 622   bfd_set_start_address (abfd, i_ehdrp->e_entry);
 623
 624   if (i_ehdrp->e_shoff != 0)
 625     {
 626       /* Seek to the section header table in the file.  */
 627       if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0)
 628         goto got_no_match;
 629
 630       /* Read the first section header at index 0, and convert to internal
 631          form.  */
 632       if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
 633         goto got_no_match;
 634       elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
 635
 636       /* If the section count is zero, the actual count is in the first
 637          section header.  */
 638       if (i_ehdrp->e_shnum == SHN_UNDEF)
 639         i_ehdrp->e_shnum = i_shdr.sh_size;
 640
 641       /* And similarly for the string table index.  */
 642       if (i_ehdrp->e_shstrndx == SHN_XINDEX)
 643         i_ehdrp->e_shstrndx = i_shdr.sh_link;
 644     }
 645
 646   /* Allocate space for a copy of the section header table in
 647      internal form.  */
 648   if (i_ehdrp->e_shnum != 0)
 649     {
 650       Elf_Internal_Shdr *shdrp;
 651       unsigned int num_sec;
 652
 653       amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
 654       i_shdrp = bfd_alloc (abfd, amt);
 655       if (!i_shdrp)
 656         goto got_no_match;
 657       num_sec = i_ehdrp->e_shnum;
 658       if (num_sec > SHN_LORESERVE)
 659         num_sec += SHN_HIRESERVE + 1 - SHN_LORESERVE;
 660       elf_numsections (abfd) = num_sec;
 661       amt = sizeof (i_shdrp) * num_sec;
 662       elf_elfsections (abfd) = bfd_alloc (abfd, amt);
 663       if (!elf_elfsections (abfd))
 664         goto got_no_match;
 665
 666       memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
 667       shdrp = i_shdrp;
 668       shindex = 0;
 669       if (num_sec > SHN_LORESERVE)
 670         {
 671           for ( ; shindex < SHN_LORESERVE; shindex++)
 672             elf_elfsections (abfd)[shindex] = shdrp++;
 673           for ( ; shindex < SHN_HIRESERVE + 1; shindex++)
 674             elf_elfsections (abfd)[shindex] = i_shdrp;
 675         }
 676       for ( ; shindex < num_sec; shindex++)
 677         elf_elfsections (abfd)[shindex] = shdrp++;
 678
 679       /* Read in the rest of the section header table and convert it
 680          to internal form.  */
 681       for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
 682         {
 683           if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
 684             goto got_no_match;
 685           elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
 686
 687           /* If the section is loaded, but not page aligned, clear
 688              D_PAGED.  */
 689           if (i_shdrp[shindex].sh_size != 0
 690               && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
 691               && i_shdrp[shindex].sh_type != SHT_NOBITS
 692               && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
 693                    % ebd->maxpagesize)
 694                   != 0))
 695             abfd->flags &= ~D_PAGED;
 696         }
 697     }
 698
 699   if (i_ehdrp->e_shstrndx && i_ehdrp->e_shoff)
 700     {
 701       if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
 702         goto got_no_match;
 703     }
 704
 705   /* Read in the program headers.  */
 706   if (i_ehdrp->e_phnum == 0)
 707     elf_tdata (abfd)->phdr = NULL;
 708   else
 709     {
 710       Elf_Internal_Phdr *i_phdr;
 711       unsigned int i;
 712
 713       amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
 714       elf_tdata (abfd)->phdr = bfd_alloc (abfd, amt);
 715       if (elf_tdata (abfd)->phdr == NULL)
 716         goto got_no_match;
 717       if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
 718         goto got_no_match;
 719       i_phdr = elf_tdata (abfd)->phdr;
 720       for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
 721         {
 722           Elf_External_Phdr x_phdr;
 723
 724           if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
 725             goto got_no_match;
 726           elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
 727         }
 728     }
 729
 730   /* Read in the string table containing the names of the sections.  We
 731      will need the base pointer to this table later.  */
 732   /* We read this inline now, so that we don't have to go through
 733      bfd_section_from_shdr with it (since this particular strtab is
 734      used to find all of the ELF section names.) */
 735
 736   if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff)
 737     {
 738       unsigned int num_sec;
 739
 740       shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
 741       if (!shstrtab)
 742         goto got_no_match;
 743
 744       /* Once all of the section headers have been read and converted, we
 745          can start processing them.  Note that the first section header is
 746          a dummy placeholder entry, so we ignore it.  */
 747       num_sec = elf_numsections (abfd);
 748       for (shindex = 1; shindex < num_sec; shindex++)
 749         {
 750           if (! bfd_section_from_shdr (abfd, shindex))
 751             goto got_no_match;
 752           if (shindex == SHN_LORESERVE - 1)
 753             shindex += SHN_HIRESERVE + 1 - SHN_LORESERVE;
 754         }
 755     }
 756
 757   /* Let the backend double check the format and override global
 758      information.  */
 759   if (ebd->elf_backend_object_p)
 760     {
 761       if (! (*ebd->elf_backend_object_p) (abfd))
 762         goto got_wrong_format_error;
 763     }
 764
 765   /* If we have created any reloc sections that are associated with
 766      debugging sections, mark the reloc sections as debugging as well.  */
 767   for (s = abfd->sections; s != NULL; s = s->next)
 768     {
 769       if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
 770            || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
 771           && elf_section_data (s)->this_hdr.sh_info > 0)
 772         {
 773           unsigned long targ_index;
 774           asection *targ_sec;
 775
 776           targ_index = elf_section_data (s)->this_hdr.sh_info;
 777           targ_sec = bfd_section_from_elf_index (abfd, targ_index);
 778           if (targ_sec != NULL
 779               && (targ_sec->flags & SEC_DEBUGGING) != 0)
 780             s->flags |= SEC_DEBUGGING;
 781         }
 782     }
 783
 784   bfd_preserve_finish (abfd, &preserve);
 785   return abfd->xvec;
 786
 787  got_wrong_format_error:
 788   /* There is way too much undoing of half-known state here.  The caller,
 789      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 790      check match/no-match like it does.  We have to rely on that a call to
 791      bfd_default_set_arch_mach with the previously known mach, undoes what
 792      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 793      For this to work, only elf-data and the mach may be changed by the
 794      target-specific elf_backend_object_p function.  Note that saving the
 795      whole bfd here and restoring it would be even worse; the first thing
 796      you notice is that the cached bfd file position gets out of sync.  */
 797   bfd_set_error (bfd_error_wrong_format);
 798
 799  got_no_match:
 800   if (preserve.marker != NULL)
 801     bfd_preserve_restore (abfd, &preserve);
 802   return NULL;
 803 }
 804 \f
 805 /* ELF .o/exec file writing */
 806
 807 /* Write out the relocs.  */
 808
 809 void
 810 elf_write_relocs (bfd *abfd, asection *sec, void *data)
 811 {
 812   bfd_boolean *failedp = data;
 813   Elf_Internal_Shdr *rela_hdr;
 814   bfd_vma addr_offset;
 815   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
 816   size_t extsize;
 817   bfd_byte *dst_rela;
 818   unsigned int idx;
 819   asymbol *last_sym;
 820   int last_sym_idx;
 821
 822   /* If we have already failed, don't do anything.  */
 823   if (*failedp)
 824     return;
 825
 826   if ((sec->flags & SEC_RELOC) == 0)
 827     return;
 828
 829   /* The linker backend writes the relocs out itself, and sets the
 830      reloc_count field to zero to inhibit writing them here.  Also,
 831      sometimes the SEC_RELOC flag gets set even when there aren't any
 832      relocs.  */
 833   if (sec->reloc_count == 0)
 834     return;
 835
 836   rela_hdr = &elf_section_data (sec)->rel_hdr;
 837
 838   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
 839   rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
 840   if (rela_hdr->contents == NULL)
 841     {
 842       *failedp = TRUE;
 843       return;
 844     }
 845
 846   /* Figure out whether the relocations are RELA or REL relocations.  */
 847   if (rela_hdr->sh_type == SHT_RELA)
 848     {
 849       swap_out = elf_swap_reloca_out;
 850       extsize = sizeof (Elf_External_Rela);
 851     }
 852   else if (rela_hdr->sh_type == SHT_REL)
 853     {
 854       swap_out = elf_swap_reloc_out;
 855       extsize = sizeof (Elf_External_Rel);
 856     }
 857   else
 858     /* Every relocation section should be either an SHT_RELA or an
 859        SHT_REL section.  */
 860     abort ();
 861
 862   /* The address of an ELF reloc is section relative for an object
 863      file, and absolute for an executable file or shared library.
 864      The address of a BFD reloc is always section relative.  */
 865   addr_offset = 0;
 866   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
 867     addr_offset = sec->vma;
 868
 869   /* orelocation has the data, reloc_count has the count...  */
 870   last_sym = 0;
 871   last_sym_idx = 0;
 872   dst_rela = rela_hdr->contents;
 873
 874   for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
 875     {
 876       Elf_Internal_Rela src_rela;
 877       arelent *ptr;
 878       asymbol *sym;
 879       int n;
 880
 881       ptr = sec->orelocation[idx];
 882       sym = *ptr->sym_ptr_ptr;
 883       if (sym == last_sym)
 884         n = last_sym_idx;
 885       else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 886         n = STN_UNDEF;
 887       else
 888         {
 889           last_sym = sym;
 890           n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 891           if (n < 0)
 892             {
 893               *failedp = TRUE;
 894               return;
 895             }
 896           last_sym_idx = n;
 897         }
 898
 899       if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
 900           && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
 901           && ! _bfd_elf_validate_reloc (abfd, ptr))
 902         {
 903           *failedp = TRUE;
 904           return;
 905         }
 906
 907       src_rela.r_offset = ptr->address + addr_offset;
 908       src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
 909       src_rela.r_addend = ptr->addend;
 910       (*swap_out) (abfd, &src_rela, dst_rela);
 911     }
 912 }
 913
 914 /* Write out the program headers.  */
 915
 916 int
 917 elf_write_out_phdrs (bfd *abfd,
 918                      const Elf_Internal_Phdr *phdr,
 919                      unsigned int count)
 920 {
 921   while (count--)
 922     {
 923       Elf_External_Phdr extphdr;
 924       elf_swap_phdr_out (abfd, phdr, &extphdr);
 925       if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
 926           != sizeof (Elf_External_Phdr))
 927         return -1;
 928       phdr++;
 929     }
 930   return 0;
 931 }
 932
 933 /* Write out the section headers and the ELF file header.  */
 934
 935 bfd_boolean
 936 elf_write_shdrs_and_ehdr (bfd *abfd)
 937 {
 938   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 939   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 940   Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
 941   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
 942   unsigned int count;
 943   bfd_size_type amt;
 944
 945   i_ehdrp = elf_elfheader (abfd);
 946   i_shdrp = elf_elfsections (abfd);
 947
 948   /* swap the header before spitting it out...  */
 949
 950 #if DEBUG & 1
 951   elf_debug_file (i_ehdrp);
 952 #endif
 953   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
 954   amt = sizeof (x_ehdr);
 955   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 956       || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
 957     return FALSE;
 958
 959   /* Some fields in the first section header handle overflow of ehdr
 960      fields.  */
 961   if (i_ehdrp->e_shnum >= SHN_LORESERVE)
 962     i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
 963   if (i_ehdrp->e_shstrndx >= SHN_LORESERVE)
 964     i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
 965
 966   /* at this point we've concocted all the ELF sections...  */
 967   amt = i_ehdrp->e_shnum;
 968   amt *= sizeof (*x_shdrp);
 969   x_shdrp = bfd_alloc (abfd, amt);
 970   if (!x_shdrp)
 971     return FALSE;
 972
 973   for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
 974     {
 975 #if DEBUG & 2
 976       elf_debug_section (count, *i_shdrp);
 977 #endif
 978       elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
 979
 980       if (count == SHN_LORESERVE - 1)
 981         i_shdrp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
 982     }
 983   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
 984       || bfd_bwrite (x_shdrp, amt, abfd) != amt)
 985     return FALSE;
 986
 987   /* need to dump the string table too...  */
 988
 989   return TRUE;
 990 }
 991
 992 long
 993 elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
 994 {
 995   Elf_Internal_Shdr *hdr;
 996   Elf_Internal_Shdr *verhdr;
 997   unsigned long symcount;       /* Number of external ELF symbols */
 998   elf_symbol_type *sym;         /* Pointer to current bfd symbol */
 999   elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
1000   Elf_Internal_Sym *isym;
1001   Elf_Internal_Sym *isymend;
1002   Elf_Internal_Sym *isymbuf = NULL;
1003   Elf_External_Versym *xver;
1004   Elf_External_Versym *xverbuf = NULL;
1005   const struct elf_backend_data *ebd;
1006   bfd_size_type amt;
1007
1008   /* Read each raw ELF symbol, converting from external ELF form to
1009      internal ELF form, and then using the information to create a
1010      canonical bfd symbol table entry.
1011
1012      Note that we allocate the initial bfd canonical symbol buffer
1013      based on a one-to-one mapping of the ELF symbols to canonical
1014      symbols.  We actually use all the ELF symbols, so there will be no
1015      space left over at the end.  When we have all the symbols, we
1016      build the caller's pointer vector.  */
1017
1018   if (! dynamic)
1019     {
1020       hdr = &elf_tdata (abfd)->symtab_hdr;
1021       verhdr = NULL;
1022     }
1023   else
1024     {
1025       hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1026       if (elf_dynversym (abfd) == 0)
1027         verhdr = NULL;
1028       else
1029         verhdr = &elf_tdata (abfd)->dynversym_hdr;
1030       if ((elf_tdata (abfd)->dynverdef_section != 0
1031            && elf_tdata (abfd)->verdef == NULL)
1032           || (elf_tdata (abfd)->dynverref_section != 0
1033               && elf_tdata (abfd)->verref == NULL))
1034         {
1035           if (! _bfd_elf_slurp_version_tables (abfd))
1036             return -1;
1037         }
1038     }
1039
1040   ebd = get_elf_backend_data (abfd);
1041   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1042   if (symcount == 0)
1043     sym = symbase = NULL;
1044   else
1045     {
1046       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1047                                       NULL, NULL, NULL);
1048       if (isymbuf == NULL)
1049         return -1;
1050
1051       amt = symcount;
1052       amt *= sizeof (elf_symbol_type);
1053       symbase = bfd_zalloc (abfd, amt);
1054       if (symbase == (elf_symbol_type *) NULL)
1055         goto error_return;
1056
1057       /* Read the raw ELF version symbol information.  */
1058       if (verhdr != NULL
1059           && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1060         {
1061           (*_bfd_error_handler)
1062             (_("%s: version count (%ld) does not match symbol count (%ld)"),
1063              abfd->filename,
1064              (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1065              symcount);
1066
1067           /* Slurp in the symbols without the version information,
1068              since that is more helpful than just quitting.  */
1069           verhdr = NULL;
1070         }
1071
1072       if (verhdr != NULL)
1073         {
1074           if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1075             goto error_return;
1076
1077           xverbuf = bfd_malloc (verhdr->sh_size);
1078           if (xverbuf == NULL && verhdr->sh_size != 0)
1079             goto error_return;
1080
1081           if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1082             goto error_return;
1083         }
1084
1085       /* Skip first symbol, which is a null dummy.  */
1086       xver = xverbuf;
1087       if (xver != NULL)
1088         ++xver;
1089       isymend = isymbuf + symcount;
1090       for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1091         {
1092           memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1093           sym->symbol.the_bfd = abfd;
1094
1095           sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1096                                                               hdr->sh_link,
1097                                                               isym->st_name);
1098
1099           sym->symbol.value = isym->st_value;
1100
1101           if (isym->st_shndx == SHN_UNDEF)
1102             {
1103               sym->symbol.section = bfd_und_section_ptr;
1104             }
1105           else if (isym->st_shndx < SHN_LORESERVE
1106                    || isym->st_shndx > SHN_HIRESERVE)
1107             {
1108               sym->symbol.section = bfd_section_from_elf_index (abfd,
1109                                                                 isym->st_shndx);
1110               if (sym->symbol.section == NULL)
1111                 {
1112                   /* This symbol is in a section for which we did not
1113                      create a BFD section.  Just use bfd_abs_section,
1114                      although it is wrong.  FIXME.  */
1115                   sym->symbol.section = bfd_abs_section_ptr;
1116                 }
1117             }
1118           else if (isym->st_shndx == SHN_ABS)
1119             {
1120               sym->symbol.section = bfd_abs_section_ptr;
1121             }
1122           else if (isym->st_shndx == SHN_COMMON)
1123             {
1124               sym->symbol.section = bfd_com_section_ptr;
1125               /* Elf puts the alignment into the `value' field, and
1126                  the size into the `size' field.  BFD wants to see the
1127                  size in the value field, and doesn't care (at the
1128                  moment) about the alignment.  */
1129               sym->symbol.value = isym->st_size;
1130             }
1131           else
1132             sym->symbol.section = bfd_abs_section_ptr;
1133
1134           /* If this is a relocatable file, then the symbol value is
1135              already section relative.  */
1136           if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1137             sym->symbol.value -= sym->symbol.section->vma;
1138
1139           switch (ELF_ST_BIND (isym->st_info))
1140             {
1141             case STB_LOCAL:
1142               sym->symbol.flags |= BSF_LOCAL;
1143               break;
1144             case STB_GLOBAL:
1145               if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1146                 sym->symbol.flags |= BSF_GLOBAL;
1147               break;
1148             case STB_WEAK:
1149               sym->symbol.flags |= BSF_WEAK;
1150               break;
1151             }
1152
1153           switch (ELF_ST_TYPE (isym->st_info))
1154             {
1155             case STT_SECTION:
1156               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1157               break;
1158             case STT_FILE:
1159               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1160               break;
1161             case STT_FUNC:
1162               sym->symbol.flags |= BSF_FUNCTION;
1163               break;
1164             case STT_OBJECT:
1165               sym->symbol.flags |= BSF_OBJECT;
1166               break;
1167             }
1168
1169           if (dynamic)
1170             sym->symbol.flags |= BSF_DYNAMIC;
1171
1172           if (xver != NULL)
1173             {
1174               Elf_Internal_Versym iversym;
1175
1176               _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1177               sym->version = iversym.vs_vers;
1178               xver++;
1179             }
1180
1181           /* Do some backend-specific processing on this symbol.  */
1182           if (ebd->elf_backend_symbol_processing)
1183             (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1184         }
1185     }
1186
1187   /* Do some backend-specific processing on this symbol table.  */
1188   if (ebd->elf_backend_symbol_table_processing)
1189     (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1190
1191   /* We rely on the zalloc to clear out the final symbol entry.  */
1192
1193   symcount = sym - symbase;
1194
1195   /* Fill in the user's symbol pointer vector if needed.  */
1196   if (symptrs)
1197     {
1198       long l = symcount;
1199
1200       sym = symbase;
1201       while (l-- > 0)
1202         {
1203           *symptrs++ = &sym->symbol;
1204           sym++;
1205         }
1206       *symptrs = 0;             /* Final null pointer */
1207     }
1208
1209   if (xverbuf != NULL)
1210     free (xverbuf);
1211   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1212     free (isymbuf);
1213   return symcount;
1214
1215 error_return:
1216   if (xverbuf != NULL)
1217     free (xverbuf);
1218   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1219     free (isymbuf);
1220   return -1;
1221 }
1222
1223 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1224    them.  */
1225
1226 static bfd_boolean
1227 elf_slurp_reloc_table_from_section (bfd *abfd,
1228                                     asection *asect,
1229                                     Elf_Internal_Shdr *rel_hdr,
1230                                     bfd_size_type reloc_count,
1231                                     arelent *relents,
1232                                     asymbol **symbols,
1233                                     bfd_boolean dynamic)
1234 {
1235   const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1236   void *allocated = NULL;
1237   bfd_byte *native_relocs;
1238   arelent *relent;
1239   unsigned int i;
1240   int entsize;
1241   unsigned int symcount;
1242
1243   allocated = bfd_malloc (rel_hdr->sh_size);
1244   if (allocated == NULL)
1245     goto error_return;
1246
1247   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1248       || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1249           != rel_hdr->sh_size))
1250     goto error_return;
1251
1252   native_relocs = allocated;
1253
1254   entsize = rel_hdr->sh_entsize;
1255   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1256               || entsize == sizeof (Elf_External_Rela));
1257
1258   if (dynamic)
1259     symcount = bfd_get_dynamic_symcount (abfd);
1260   else
1261     symcount = bfd_get_symcount (abfd);
1262
1263   for (i = 0, relent = relents;
1264        i < reloc_count;
1265        i++, relent++, native_relocs += entsize)
1266     {
1267       Elf_Internal_Rela rela;
1268
1269       if (entsize == sizeof (Elf_External_Rela))
1270         elf_swap_reloca_in (abfd, native_relocs, &rela);
1271       else
1272         elf_swap_reloc_in (abfd, native_relocs, &rela);
1273
1274       /* The address of an ELF reloc is section relative for an object
1275          file, and absolute for an executable file or shared library.
1276          The address of a normal BFD reloc is always section relative,
1277          and the address of a dynamic reloc is absolute..  */
1278       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1279         relent->address = rela.r_offset;
1280       else
1281         relent->address = rela.r_offset - asect->vma;
1282
1283       if (ELF_R_SYM (rela.r_info) == 0)
1284         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1285       else if (ELF_R_SYM (rela.r_info) > symcount)
1286         {
1287           (*_bfd_error_handler)
1288             (_("%s(%s): relocation %d has invalid symbol index %ld"),
1289              abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1290           relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1291         }
1292       else
1293         {
1294           asymbol **ps, *s;
1295
1296           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1297           s = *ps;
1298
1299           /* Canonicalize ELF section symbols.  FIXME: Why?  */
1300           if ((s->flags & BSF_SECTION_SYM) == 0)
1301             relent->sym_ptr_ptr = ps;
1302           else
1303             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1304         }
1305
1306       relent->addend = rela.r_addend;
1307
1308       if ((entsize == sizeof (Elf_External_Rela)
1309            && ebd->elf_info_to_howto != NULL)
1310           || ebd->elf_info_to_howto_rel == NULL)
1311         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1312       else
1313         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1314     }
1315
1316   if (allocated != NULL)
1317     free (allocated);
1318
1319   return TRUE;
1320
1321  error_return:
1322   if (allocated != NULL)
1323     free (allocated);
1324   return FALSE;
1325 }
1326
1327 /* Read in and swap the external relocs.  */
1328
1329 bfd_boolean
1330 elf_slurp_reloc_table (bfd *abfd,
1331                        asection *asect,
1332                        asymbol **symbols,
1333                        bfd_boolean dynamic)
1334 {
1335   struct bfd_elf_section_data * const d = elf_section_data (asect);
1336   Elf_Internal_Shdr *rel_hdr;
1337   Elf_Internal_Shdr *rel_hdr2;
1338   bfd_size_type reloc_count;
1339   bfd_size_type reloc_count2;
1340   arelent *relents;
1341   bfd_size_type amt;
1342
1343   if (asect->relocation != NULL)
1344     return TRUE;
1345
1346   if (! dynamic)
1347     {
1348       if ((asect->flags & SEC_RELOC) == 0
1349           || asect->reloc_count == 0)
1350         return TRUE;
1351
1352       rel_hdr = &d->rel_hdr;
1353       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1354       rel_hdr2 = d->rel_hdr2;
1355       reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1356
1357       BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1358       BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1359                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1360
1361     }
1362   else
1363     {
1364       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1365          case because relocations against this section may use the
1366          dynamic symbol table, and in that case bfd_section_from_shdr
1367          in elf.c does not update the RELOC_COUNT.  */
1368       if (asect->_raw_size == 0)
1369         return TRUE;
1370
1371       rel_hdr = &d->this_hdr;
1372       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1373       rel_hdr2 = NULL;
1374       reloc_count2 = 0;
1375     }
1376
1377   amt = (reloc_count + reloc_count2) * sizeof (arelent);
1378   relents = bfd_alloc (abfd, amt);
1379   if (relents == NULL)
1380     return FALSE;
1381
1382   if (!elf_slurp_reloc_table_from_section (abfd, asect,
1383                                            rel_hdr, reloc_count,
1384                                            relents,
1385                                            symbols, dynamic))
1386     return FALSE;
1387
1388   if (rel_hdr2
1389       && !elf_slurp_reloc_table_from_section (abfd, asect,
1390                                               rel_hdr2, reloc_count2,
1391                                               relents + reloc_count,
1392                                               symbols, dynamic))
1393     return FALSE;
1394
1395   asect->relocation = relents;
1396   return TRUE;
1397 }
1398
1399 #ifdef DEBUG
1400 static void
1401 elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1402 {
1403   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1404            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1405            (long) hdr);
1406   fprintf (stderr,
1407            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1408            (long) hdr->sh_name,
1409            (long) hdr->sh_type,
1410            (long) hdr->sh_flags);
1411   fprintf (stderr,
1412            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1413            (long) hdr->sh_addr,
1414            (long) hdr->sh_offset,
1415            (long) hdr->sh_size);
1416   fprintf (stderr,
1417            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1418            (long) hdr->sh_link,
1419            (long) hdr->sh_info,
1420            (long) hdr->sh_addralign);
1421   fprintf (stderr, "sh_entsize   = %ld\n",
1422            (long) hdr->sh_entsize);
1423   fflush (stderr);
1424 }
1425
1426 static void
1427 elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1428 {
1429   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1430   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1431   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1432   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1433   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1434   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1435   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1436 }
1437
1438 static char *
1439 elf_symbol_flags (flagword flags)
1440 {
1441   static char buffer[1024];
1442
1443   buffer[0] = '\0';
1444   if (flags & BSF_LOCAL)
1445     strcat (buffer, " local");
1446
1447   if (flags & BSF_GLOBAL)
1448     strcat (buffer, " global");
1449
1450   if (flags & BSF_DEBUGGING)
1451     strcat (buffer, " debug");
1452
1453   if (flags & BSF_FUNCTION)
1454     strcat (buffer, " function");
1455
1456   if (flags & BSF_KEEP)
1457     strcat (buffer, " keep");
1458
1459   if (flags & BSF_KEEP_G)
1460     strcat (buffer, " keep_g");
1461
1462   if (flags & BSF_WEAK)
1463     strcat (buffer, " weak");
1464
1465   if (flags & BSF_SECTION_SYM)
1466     strcat (buffer, " section-sym");
1467
1468   if (flags & BSF_OLD_COMMON)
1469     strcat (buffer, " old-common");
1470
1471   if (flags & BSF_NOT_AT_END)
1472     strcat (buffer, " not-at-end");
1473
1474   if (flags & BSF_CONSTRUCTOR)
1475     strcat (buffer, " constructor");
1476
1477   if (flags & BSF_WARNING)
1478     strcat (buffer, " warning");
1479
1480   if (flags & BSF_INDIRECT)
1481     strcat (buffer, " indirect");
1482
1483   if (flags & BSF_FILE)
1484     strcat (buffer, " file");
1485
1486   if (flags & DYNAMIC)
1487     strcat (buffer, " dynamic");
1488
1489   if (flags & ~(BSF_LOCAL
1490                 | BSF_GLOBAL
1491                 | BSF_DEBUGGING
1492                 | BSF_FUNCTION
1493                 | BSF_KEEP
1494                 | BSF_KEEP_G
1495                 | BSF_WEAK
1496                 | BSF_SECTION_SYM
1497                 | BSF_OLD_COMMON
1498                 | BSF_NOT_AT_END
1499                 | BSF_CONSTRUCTOR
1500                 | BSF_WARNING
1501                 | BSF_INDIRECT
1502                 | BSF_FILE
1503                 | BSF_DYNAMIC))
1504     strcat (buffer, " unknown-bits");
1505
1506   return buffer;
1507 }
1508 #endif
1509 \f
1510 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
1511    reconstruct an ELF file by reading the segments out of remote memory
1512    based on the ELF file header at EHDR_VMA and the ELF program headers it
1513    points to.  If not null, *LOADBASEP is filled in with the difference
1514    between the VMAs from which the segments were read, and the VMAs the
1515    file headers (and hence BFD's idea of each section's VMA) put them at.
1516
1517    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1518    remote memory at target address VMA into the local buffer at MYADDR; it
1519    should return zero on success or an `errno' code on failure.  TEMPL must
1520    be a BFD for a target with the word size and byte order found in the
1521    remote memory.  */
1522
1523 bfd *
1524 NAME(_bfd_elf,bfd_from_remote_memory)
1525   (bfd *templ,
1526    bfd_vma ehdr_vma,
1527    bfd_vma *loadbasep,
1528    int (*target_read_memory) (bfd_vma, char *, int))
1529 {
1530   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
1531   Elf_Internal_Ehdr i_ehdr;     /* Elf file header, internal form */
1532   Elf_External_Phdr *x_phdrs;
1533   Elf_Internal_Phdr *i_phdrs, *last_phdr;
1534   bfd *nbfd;
1535   struct bfd_in_memory *bim;
1536   int contents_size;
1537   char *contents;
1538   int err;
1539   unsigned int i;
1540   bfd_vma loadbase;
1541
1542   /* Read in the ELF header in external format.  */
1543   err = target_read_memory (ehdr_vma, (char *) &x_ehdr, sizeof x_ehdr);
1544   if (err)
1545     {
1546       bfd_set_error (bfd_error_system_call);
1547       errno = err;
1548       return NULL;
1549     }
1550
1551   /* Now check to see if we have a valid ELF file, and one that BFD can
1552      make use of.  The magic number must match, the address size ('class')
1553      and byte-swapping must match our XVEC entry.  */
1554
1555   if (! elf_file_p (&x_ehdr)
1556       || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1557       || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1558     {
1559       bfd_set_error (bfd_error_wrong_format);
1560       return NULL;
1561     }
1562
1563   /* Check that file's byte order matches xvec's */
1564   switch (x_ehdr.e_ident[EI_DATA])
1565     {
1566     case ELFDATA2MSB:           /* Big-endian */
1567       if (! bfd_header_big_endian (templ))
1568         {
1569           bfd_set_error (bfd_error_wrong_format);
1570           return NULL;
1571         }
1572       break;
1573     case ELFDATA2LSB:           /* Little-endian */
1574       if (! bfd_header_little_endian (templ))
1575         {
1576           bfd_set_error (bfd_error_wrong_format);
1577           return NULL;
1578         }
1579       break;
1580     case ELFDATANONE:           /* No data encoding specified */
1581     default:                    /* Unknown data encoding specified */
1582       bfd_set_error (bfd_error_wrong_format);
1583       return NULL;
1584     }
1585
1586   elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1587
1588   /* The file header tells where to find the program headers.
1589      These are what we use to actually choose what to read.  */
1590
1591   if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1592     {
1593       bfd_set_error (bfd_error_wrong_format);
1594       return NULL;
1595     }
1596
1597   x_phdrs = bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1598   if (x_phdrs == NULL)
1599     {
1600       bfd_set_error (bfd_error_no_memory);
1601       return NULL;
1602     }
1603   err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (char *) x_phdrs,
1604                             i_ehdr.e_phnum * sizeof x_phdrs[0]);
1605   if (err)
1606     {
1607       free (x_phdrs);
1608       bfd_set_error (bfd_error_system_call);
1609       errno = err;
1610       return NULL;
1611     }
1612   i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1613
1614   contents_size = 0;
1615   last_phdr = NULL;
1616   loadbase = ehdr_vma;
1617   for (i = 0; i < i_ehdr.e_phnum; ++i)
1618     {
1619       elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1620       if (i_phdrs[i].p_type == PT_LOAD)
1621         {
1622           bfd_vma segment_end;
1623           segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1624                          + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1625           if (segment_end > (bfd_vma) contents_size)
1626             contents_size = segment_end;
1627
1628           if ((i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1629             loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1630
1631           last_phdr = &i_phdrs[i];
1632         }
1633     }
1634   if (last_phdr == NULL)
1635     {
1636       /* There were no PT_LOAD segments, so we don't have anything to read.  */
1637       free (x_phdrs);
1638       bfd_set_error (bfd_error_wrong_format);
1639       return NULL;
1640     }
1641
1642   /* Trim the last segment so we don't bother with zeros in the last page
1643      that are off the end of the file.  However, if the extra bit in that
1644      page includes the section headers, keep them.  */
1645   if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1646       && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1647                                      + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1648     {
1649       contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1650       if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1651                                      + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1652         contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1653     }
1654   else
1655     contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1656
1657   /* Now we know the size of the whole image we want read in.  */
1658   contents = bfd_zmalloc (contents_size);
1659   if (contents == NULL)
1660     {
1661       free (x_phdrs);
1662       bfd_set_error (bfd_error_no_memory);
1663       return NULL;
1664     }
1665
1666   for (i = 0; i < i_ehdr.e_phnum; ++i)
1667     if (i_phdrs[i].p_type == PT_LOAD)
1668       {
1669         bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1670         bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1671                        + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1672         if (end > (bfd_vma) contents_size)
1673           end = contents_size;
1674         err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1675                                   & -i_phdrs[i].p_align,
1676                                   contents + start, end - start);
1677         if (err)
1678           {
1679             free (x_phdrs);
1680             free (contents);
1681             bfd_set_error (bfd_error_system_call);
1682             errno = err;
1683             return NULL;
1684           }
1685       }
1686   free (x_phdrs);
1687
1688   /* If the segments visible in memory didn't include the section headers,
1689      then clear them from the file header.  */
1690   if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1691                                  + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1692     {
1693       memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1694       memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1695       memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1696     }
1697
1698   /* This will normally have been in the first PT_LOAD segment.  But it
1699      conceivably could be missing, and we might have just changed it.  */
1700   memcpy (contents, &x_ehdr, sizeof x_ehdr);
1701
1702   /* Now we have a memory image of the ELF file contents.  Make a BFD.  */
1703   bim = bfd_malloc (sizeof (struct bfd_in_memory));
1704   if (bim == NULL)
1705     {
1706       free (contents);
1707       bfd_set_error (bfd_error_no_memory);
1708       return NULL;
1709     }
1710   nbfd = _bfd_new_bfd ();
1711   if (nbfd == NULL)
1712     {
1713       free (bim);
1714       free (contents);
1715       bfd_set_error (bfd_error_no_memory);
1716       return NULL;
1717     }
1718   nbfd->filename = "<in-memory>";
1719   nbfd->xvec = templ->xvec;
1720   bim->size = contents_size;
1721   bim->buffer = contents;
1722   nbfd->iostream = bim;
1723   nbfd->flags = BFD_IN_MEMORY;
1724   nbfd->direction = read_direction;
1725   nbfd->mtime = time (NULL);
1726   nbfd->mtime_set = TRUE;
1727
1728   if (loadbasep)
1729     *loadbasep = loadbase;
1730   return nbfd;
1731 }
1732 \f
1733 #include "elfcore.h"
1734 #include "elflink.h"
1735 \f
1736 /* Size-dependent data and functions.  */
1737 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1738   sizeof (Elf_External_Ehdr),
1739   sizeof (Elf_External_Phdr),
1740   sizeof (Elf_External_Shdr),
1741   sizeof (Elf_External_Rel),
1742   sizeof (Elf_External_Rela),
1743   sizeof (Elf_External_Sym),
1744   sizeof (Elf_External_Dyn),
1745   sizeof (Elf_External_Note),
1746   4,
1747   1,
1748   ARCH_SIZE, LOG_FILE_ALIGN,
1749   ELFCLASS, EV_CURRENT,
1750   elf_write_out_phdrs,
1751   elf_write_shdrs_and_ehdr,
1752   elf_write_relocs,
1753   elf_swap_symbol_in,
1754   elf_swap_symbol_out,
1755   elf_slurp_reloc_table,
1756   elf_slurp_symbol_table,
1757   elf_swap_dyn_in,
1758   elf_swap_dyn_out,
1759   elf_swap_reloc_in,
1760   elf_swap_reloc_out,
1761   elf_swap_reloca_in,
1762   elf_swap_reloca_out
1763 };