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