contrib/gdb-6.2.1/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
 747   /* Let the backend double check the format and override global
 748      information.  */
 749   if (ebd->elf_backend_object_p)
 750     {
 751       if (! (*ebd->elf_backend_object_p) (abfd))
 752         goto got_wrong_format_error;
 753     }
 754
 755   /* If we have created any reloc sections that are associated with
 756      debugging sections, mark the reloc sections as debugging as well.  */
 757   for (s = abfd->sections; s != NULL; s = s->next)
 758     {
 759       if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
 760            || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
 761           && elf_section_data (s)->this_hdr.sh_info > 0)
 762         {
 763           unsigned long targ_index;
 764           asection *targ_sec;
 765
 766           targ_index = elf_section_data (s)->this_hdr.sh_info;
 767           targ_sec = bfd_section_from_elf_index (abfd, targ_index);
 768           if (targ_sec != NULL
 769               && (targ_sec->flags & SEC_DEBUGGING) != 0)
 770             s->flags |= SEC_DEBUGGING;
 771         }
 772     }
 773
 774   bfd_preserve_finish (abfd, &preserve);
 775   return abfd->xvec;
 776
 777  got_wrong_format_error:
 778   /* There is way too much undoing of half-known state here.  The caller,
 779      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 780      check match/no-match like it does.  We have to rely on that a call to
 781      bfd_default_set_arch_mach with the previously known mach, undoes what
 782      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 783      For this to work, only elf-data and the mach may be changed by the
 784      target-specific elf_backend_object_p function.  Note that saving the
 785      whole bfd here and restoring it would be even worse; the first thing
 786      you notice is that the cached bfd file position gets out of sync.  */
 787   bfd_set_error (bfd_error_wrong_format);
 788
 789  got_no_match:
 790   if (preserve.marker != NULL)
 791     bfd_preserve_restore (abfd, &preserve);
 792   return NULL;
 793 }
 794 \f
 795 /* ELF .o/exec file writing */
 796
 797 /* Write out the relocs.  */
 798
 799 void
 800 elf_write_relocs (bfd *abfd, asection *sec, void *data)
 801 {
 802   bfd_boolean *failedp = data;
 803   Elf_Internal_Shdr *rela_hdr;
 804   bfd_vma addr_offset;
 805   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
 806   size_t extsize;
 807   bfd_byte *dst_rela;
 808   unsigned int idx;
 809   asymbol *last_sym;
 810   int last_sym_idx;
 811
 812   /* If we have already failed, don't do anything.  */
 813   if (*failedp)
 814     return;
 815
 816   if ((sec->flags & SEC_RELOC) == 0)
 817     return;
 818
 819   /* The linker backend writes the relocs out itself, and sets the
 820      reloc_count field to zero to inhibit writing them here.  Also,
 821      sometimes the SEC_RELOC flag gets set even when there aren't any
 822      relocs.  */
 823   if (sec->reloc_count == 0)
 824     return;
 825
 826   rela_hdr = &elf_section_data (sec)->rel_hdr;
 827
 828   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
 829   rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
 830   if (rela_hdr->contents == NULL)
 831     {
 832       *failedp = TRUE;
 833       return;
 834     }
 835
 836   /* Figure out whether the relocations are RELA or REL relocations.  */
 837   if (rela_hdr->sh_type == SHT_RELA)
 838     {
 839       swap_out = elf_swap_reloca_out;
 840       extsize = sizeof (Elf_External_Rela);
 841     }
 842   else if (rela_hdr->sh_type == SHT_REL)
 843     {
 844       swap_out = elf_swap_reloc_out;
 845       extsize = sizeof (Elf_External_Rel);
 846     }
 847   else
 848     /* Every relocation section should be either an SHT_RELA or an
 849        SHT_REL section.  */
 850     abort ();
 851
 852   /* The address of an ELF reloc is section relative for an object
 853      file, and absolute for an executable file or shared library.
 854      The address of a BFD reloc is always section relative.  */
 855   addr_offset = 0;
 856   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
 857     addr_offset = sec->vma;
 858
 859   /* orelocation has the data, reloc_count has the count...  */
 860   last_sym = 0;
 861   last_sym_idx = 0;
 862   dst_rela = rela_hdr->contents;
 863
 864   for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
 865     {
 866       Elf_Internal_Rela src_rela;
 867       arelent *ptr;
 868       asymbol *sym;
 869       int n;
 870
 871       ptr = sec->orelocation[idx];
 872       sym = *ptr->sym_ptr_ptr;
 873       if (sym == last_sym)
 874         n = last_sym_idx;
 875       else if (bfd_is_abs_section (sym->section) && sym->value == 0)
 876         n = STN_UNDEF;
 877       else
 878         {
 879           last_sym = sym;
 880           n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
 881           if (n < 0)
 882             {
 883               *failedp = TRUE;
 884               return;
 885             }
 886           last_sym_idx = n;
 887         }
 888
 889       if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
 890           && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
 891           && ! _bfd_elf_validate_reloc (abfd, ptr))
 892         {
 893           *failedp = TRUE;
 894           return;
 895         }
 896
 897       src_rela.r_offset = ptr->address + addr_offset;
 898       src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
 899       src_rela.r_addend = ptr->addend;
 900       (*swap_out) (abfd, &src_rela, dst_rela);
 901     }
 902 }
 903
 904 /* Write out the program headers.  */
 905
 906 int
 907 elf_write_out_phdrs (bfd *abfd,
 908                      const Elf_Internal_Phdr *phdr,
 909                      unsigned int count)
 910 {
 911   while (count--)
 912     {
 913       Elf_External_Phdr extphdr;
 914       elf_swap_phdr_out (abfd, phdr, &extphdr);
 915       if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
 916           != sizeof (Elf_External_Phdr))
 917         return -1;
 918       phdr++;
 919     }
 920   return 0;
 921 }
 922
 923 /* Write out the section headers and the ELF file header.  */
 924
 925 bfd_boolean
 926 elf_write_shdrs_and_ehdr (bfd *abfd)
 927 {
 928   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
 929   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
 930   Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
 931   Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
 932   unsigned int count;
 933   bfd_size_type amt;
 934
 935   i_ehdrp = elf_elfheader (abfd);
 936   i_shdrp = elf_elfsections (abfd);
 937
 938   /* swap the header before spitting it out...  */
 939
 940 #if DEBUG & 1
 941   elf_debug_file (i_ehdrp);
 942 #endif
 943   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
 944   amt = sizeof (x_ehdr);
 945   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 946       || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
 947     return FALSE;
 948
 949   /* Some fields in the first section header handle overflow of ehdr
 950      fields.  */
 951   if (i_ehdrp->e_shnum >= SHN_LORESERVE)
 952     i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
 953   if (i_ehdrp->e_shstrndx >= SHN_LORESERVE)
 954     i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
 955
 956   /* at this point we've concocted all the ELF sections...  */
 957   amt = i_ehdrp->e_shnum;
 958   amt *= sizeof (*x_shdrp);
 959   x_shdrp = bfd_alloc (abfd, amt);
 960   if (!x_shdrp)
 961     return FALSE;
 962
 963   for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
 964     {
 965 #if DEBUG & 2
 966       elf_debug_section (count, *i_shdrp);
 967 #endif
 968       elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
 969
 970       if (count == SHN_LORESERVE - 1)
 971         i_shdrp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
 972     }
 973   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
 974       || bfd_bwrite (x_shdrp, amt, abfd) != amt)
 975     return FALSE;
 976
 977   /* need to dump the string table too...  */
 978
 979   return TRUE;
 980 }
 981
 982 long
 983 elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
 984 {
 985   Elf_Internal_Shdr *hdr;
 986   Elf_Internal_Shdr *verhdr;
 987   unsigned long symcount;       /* Number of external ELF symbols */
 988   elf_symbol_type *sym;         /* Pointer to current bfd symbol */
 989   elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
 990   Elf_Internal_Sym *isym;
 991   Elf_Internal_Sym *isymend;
 992   Elf_Internal_Sym *isymbuf = NULL;
 993   Elf_External_Versym *xver;
 994   Elf_External_Versym *xverbuf = NULL;
 995   const struct elf_backend_data *ebd;
 996   bfd_size_type amt;
 997
 998   /* Read each raw ELF symbol, converting from external ELF form to
 999      internal ELF form, and then using the information to create a
1000      canonical bfd symbol table entry.
1001
1002      Note that we allocate the initial bfd canonical symbol buffer
1003      based on a one-to-one mapping of the ELF symbols to canonical
1004      symbols.  We actually use all the ELF symbols, so there will be no
1005      space left over at the end.  When we have all the symbols, we
1006      build the caller's pointer vector.  */
1007
1008   if (! dynamic)
1009     {
1010       hdr = &elf_tdata (abfd)->symtab_hdr;
1011       verhdr = NULL;
1012     }
1013   else
1014     {
1015       hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1016       if (elf_dynversym (abfd) == 0)
1017         verhdr = NULL;
1018       else
1019         verhdr = &elf_tdata (abfd)->dynversym_hdr;
1020       if ((elf_tdata (abfd)->dynverdef_section != 0
1021            && elf_tdata (abfd)->verdef == NULL)
1022           || (elf_tdata (abfd)->dynverref_section != 0
1023               && elf_tdata (abfd)->verref == NULL))
1024         {
1025           if (! _bfd_elf_slurp_version_tables (abfd))
1026             return -1;
1027         }
1028     }
1029
1030   ebd = get_elf_backend_data (abfd);
1031   symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1032   if (symcount == 0)
1033     sym = symbase = NULL;
1034   else
1035     {
1036       isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1037                                       NULL, NULL, NULL);
1038       if (isymbuf == NULL)
1039         return -1;
1040
1041       amt = symcount;
1042       amt *= sizeof (elf_symbol_type);
1043       symbase = bfd_zalloc (abfd, amt);
1044       if (symbase == (elf_symbol_type *) NULL)
1045         goto error_return;
1046
1047       /* Read the raw ELF version symbol information.  */
1048       if (verhdr != NULL
1049           && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1050         {
1051           (*_bfd_error_handler)
1052             (_("%s: version count (%ld) does not match symbol count (%ld)"),
1053              abfd->filename,
1054              (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1055              symcount);
1056
1057           /* Slurp in the symbols without the version information,
1058              since that is more helpful than just quitting.  */
1059           verhdr = NULL;
1060         }
1061
1062       if (verhdr != NULL)
1063         {
1064           if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1065             goto error_return;
1066
1067           xverbuf = bfd_malloc (verhdr->sh_size);
1068           if (xverbuf == NULL && verhdr->sh_size != 0)
1069             goto error_return;
1070
1071           if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1072             goto error_return;
1073         }
1074
1075       /* Skip first symbol, which is a null dummy.  */
1076       xver = xverbuf;
1077       if (xver != NULL)
1078         ++xver;
1079       isymend = isymbuf + symcount;
1080       for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1081         {
1082           memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1083           sym->symbol.the_bfd = abfd;
1084
1085           sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1086                                                               hdr->sh_link,
1087                                                               isym->st_name);
1088
1089           sym->symbol.value = isym->st_value;
1090
1091           if (isym->st_shndx == SHN_UNDEF)
1092             {
1093               sym->symbol.section = bfd_und_section_ptr;
1094             }
1095           else if (isym->st_shndx < SHN_LORESERVE
1096                    || isym->st_shndx > SHN_HIRESERVE)
1097             {
1098               sym->symbol.section = bfd_section_from_elf_index (abfd,
1099                                                                 isym->st_shndx);
1100               if (sym->symbol.section == NULL)
1101                 {
1102                   /* This symbol is in a section for which we did not
1103                      create a BFD section.  Just use bfd_abs_section,
1104                      although it is wrong.  FIXME.  */
1105                   sym->symbol.section = bfd_abs_section_ptr;
1106                 }
1107             }
1108           else if (isym->st_shndx == SHN_ABS)
1109             {
1110               sym->symbol.section = bfd_abs_section_ptr;
1111             }
1112           else if (isym->st_shndx == SHN_COMMON)
1113             {
1114               sym->symbol.section = bfd_com_section_ptr;
1115               /* Elf puts the alignment into the `value' field, and
1116                  the size into the `size' field.  BFD wants to see the
1117                  size in the value field, and doesn't care (at the
1118                  moment) about the alignment.  */
1119               sym->symbol.value = isym->st_size;
1120             }
1121           else
1122             sym->symbol.section = bfd_abs_section_ptr;
1123
1124           /* If this is a relocatable file, then the symbol value is
1125              already section relative.  */
1126           if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1127             sym->symbol.value -= sym->symbol.section->vma;
1128
1129           switch (ELF_ST_BIND (isym->st_info))
1130             {
1131             case STB_LOCAL:
1132               sym->symbol.flags |= BSF_LOCAL;
1133               break;
1134             case STB_GLOBAL:
1135               if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1136                 sym->symbol.flags |= BSF_GLOBAL;
1137               break;
1138             case STB_WEAK:
1139               sym->symbol.flags |= BSF_WEAK;
1140               break;
1141             }
1142
1143           switch (ELF_ST_TYPE (isym->st_info))
1144             {
1145             case STT_SECTION:
1146               sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1147               break;
1148             case STT_FILE:
1149               sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1150               break;
1151             case STT_FUNC:
1152               sym->symbol.flags |= BSF_FUNCTION;
1153               break;
1154             case STT_OBJECT:
1155               sym->symbol.flags |= BSF_OBJECT;
1156               break;
1157             }
1158
1159           if (dynamic)
1160             sym->symbol.flags |= BSF_DYNAMIC;
1161
1162           if (xver != NULL)
1163             {
1164               Elf_Internal_Versym iversym;
1165
1166               _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1167               sym->version = iversym.vs_vers;
1168               xver++;
1169             }
1170
1171           /* Do some backend-specific processing on this symbol.  */
1172           if (ebd->elf_backend_symbol_processing)
1173             (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1174         }
1175     }
1176
1177   /* Do some backend-specific processing on this symbol table.  */
1178   if (ebd->elf_backend_symbol_table_processing)
1179     (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1180
1181   /* We rely on the zalloc to clear out the final symbol entry.  */
1182
1183   symcount = sym - symbase;
1184
1185   /* Fill in the user's symbol pointer vector if needed.  */
1186   if (symptrs)
1187     {
1188       long l = symcount;
1189
1190       sym = symbase;
1191       while (l-- > 0)
1192         {
1193           *symptrs++ = &sym->symbol;
1194           sym++;
1195         }
1196       *symptrs = 0;             /* Final null pointer */
1197     }
1198
1199   if (xverbuf != NULL)
1200     free (xverbuf);
1201   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1202     free (isymbuf);
1203   return symcount;
1204
1205 error_return:
1206   if (xverbuf != NULL)
1207     free (xverbuf);
1208   if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1209     free (isymbuf);
1210   return -1;
1211 }
1212
1213 /* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1214    them.  */
1215
1216 static bfd_boolean
1217 elf_slurp_reloc_table_from_section (bfd *abfd,
1218                                     asection *asect,
1219                                     Elf_Internal_Shdr *rel_hdr,
1220                                     bfd_size_type reloc_count,
1221                                     arelent *relents,
1222                                     asymbol **symbols,
1223                                     bfd_boolean dynamic)
1224 {
1225   const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1226   void *allocated = NULL;
1227   bfd_byte *native_relocs;
1228   arelent *relent;
1229   unsigned int i;
1230   int entsize;
1231   unsigned int symcount;
1232
1233   allocated = bfd_malloc (rel_hdr->sh_size);
1234   if (allocated == NULL)
1235     goto error_return;
1236
1237   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1238       || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1239           != rel_hdr->sh_size))
1240     goto error_return;
1241
1242   native_relocs = allocated;
1243
1244   entsize = rel_hdr->sh_entsize;
1245   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1246               || entsize == sizeof (Elf_External_Rela));
1247
1248   if (dynamic)
1249     symcount = bfd_get_dynamic_symcount (abfd);
1250   else
1251     symcount = bfd_get_symcount (abfd);
1252
1253   for (i = 0, relent = relents;
1254        i < reloc_count;
1255        i++, relent++, native_relocs += entsize)
1256     {
1257       Elf_Internal_Rela rela;
1258
1259       if (entsize == sizeof (Elf_External_Rela))
1260         elf_swap_reloca_in (abfd, native_relocs, &rela);
1261       else
1262         elf_swap_reloc_in (abfd, native_relocs, &rela);
1263
1264       /* The address of an ELF reloc is section relative for an object
1265          file, and absolute for an executable file or shared library.
1266          The address of a normal BFD reloc is always section relative,
1267          and the address of a dynamic reloc is absolute..  */
1268       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1269         relent->address = rela.r_offset;
1270       else
1271         relent->address = rela.r_offset - asect->vma;
1272
1273       if (ELF_R_SYM (rela.r_info) == 0)
1274         relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1275       else if (ELF_R_SYM (rela.r_info) > symcount)
1276         {
1277           (*_bfd_error_handler)
1278             (_("%s(%s): relocation %d has invalid symbol index %ld"),
1279              abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1280           relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1281         }
1282       else
1283         {
1284           asymbol **ps, *s;
1285
1286           ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1287           s = *ps;
1288
1289           /* Canonicalize ELF section symbols.  FIXME: Why?  */
1290           if ((s->flags & BSF_SECTION_SYM) == 0)
1291             relent->sym_ptr_ptr = ps;
1292           else
1293             relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1294         }
1295
1296       relent->addend = rela.r_addend;
1297
1298       if ((entsize == sizeof (Elf_External_Rela)
1299            && ebd->elf_info_to_howto != NULL)
1300           || ebd->elf_info_to_howto_rel == NULL)
1301         (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1302       else
1303         (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1304     }
1305
1306   if (allocated != NULL)
1307     free (allocated);
1308
1309   return TRUE;
1310
1311  error_return:
1312   if (allocated != NULL)
1313     free (allocated);
1314   return FALSE;
1315 }
1316
1317 /* Read in and swap the external relocs.  */
1318
1319 bfd_boolean
1320 elf_slurp_reloc_table (bfd *abfd,
1321                        asection *asect,
1322                        asymbol **symbols,
1323                        bfd_boolean dynamic)
1324 {
1325   struct bfd_elf_section_data * const d = elf_section_data (asect);
1326   Elf_Internal_Shdr *rel_hdr;
1327   Elf_Internal_Shdr *rel_hdr2;
1328   bfd_size_type reloc_count;
1329   bfd_size_type reloc_count2;
1330   arelent *relents;
1331   bfd_size_type amt;
1332
1333   if (asect->relocation != NULL)
1334     return TRUE;
1335
1336   if (! dynamic)
1337     {
1338       if ((asect->flags & SEC_RELOC) == 0
1339           || asect->reloc_count == 0)
1340         return TRUE;
1341
1342       rel_hdr = &d->rel_hdr;
1343       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1344       rel_hdr2 = d->rel_hdr2;
1345       reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1346
1347       BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1348       BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1349                   || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1350
1351     }
1352   else
1353     {
1354       /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1355          case because relocations against this section may use the
1356          dynamic symbol table, and in that case bfd_section_from_shdr
1357          in elf.c does not update the RELOC_COUNT.  */
1358       if (asect->size == 0)
1359         return TRUE;
1360
1361       rel_hdr = &d->this_hdr;
1362       reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1363       rel_hdr2 = NULL;
1364       reloc_count2 = 0;
1365     }
1366
1367   amt = (reloc_count + reloc_count2) * sizeof (arelent);
1368   relents = bfd_alloc (abfd, amt);
1369   if (relents == NULL)
1370     return FALSE;
1371
1372   if (!elf_slurp_reloc_table_from_section (abfd, asect,
1373                                            rel_hdr, reloc_count,
1374                                            relents,
1375                                            symbols, dynamic))
1376     return FALSE;
1377
1378   if (rel_hdr2
1379       && !elf_slurp_reloc_table_from_section (abfd, asect,
1380                                               rel_hdr2, reloc_count2,
1381                                               relents + reloc_count,
1382                                               symbols, dynamic))
1383     return FALSE;
1384
1385   asect->relocation = relents;
1386   return TRUE;
1387 }
1388
1389 #ifdef DEBUG
1390 static void
1391 elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1392 {
1393   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1394            hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1395            (long) hdr);
1396   fprintf (stderr,
1397            "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1398            (long) hdr->sh_name,
1399            (long) hdr->sh_type,
1400            (long) hdr->sh_flags);
1401   fprintf (stderr,
1402            "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1403            (long) hdr->sh_addr,
1404            (long) hdr->sh_offset,
1405            (long) hdr->sh_size);
1406   fprintf (stderr,
1407            "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1408            (long) hdr->sh_link,
1409            (long) hdr->sh_info,
1410            (long) hdr->sh_addralign);
1411   fprintf (stderr, "sh_entsize   = %ld\n",
1412            (long) hdr->sh_entsize);
1413   fflush (stderr);
1414 }
1415
1416 static void
1417 elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1418 {
1419   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1420   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1421   fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1422   fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1423   fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1424   fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1425   fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1426 }
1427
1428 static char *
1429 elf_symbol_flags (flagword flags)
1430 {
1431   static char buffer[1024];
1432
1433   buffer[0] = '\0';
1434   if (flags & BSF_LOCAL)
1435     strcat (buffer, " local");
1436
1437   if (flags & BSF_GLOBAL)
1438     strcat (buffer, " global");
1439
1440   if (flags & BSF_DEBUGGING)
1441     strcat (buffer, " debug");
1442
1443   if (flags & BSF_FUNCTION)
1444     strcat (buffer, " function");
1445
1446   if (flags & BSF_KEEP)
1447     strcat (buffer, " keep");
1448
1449   if (flags & BSF_KEEP_G)
1450     strcat (buffer, " keep_g");
1451
1452   if (flags & BSF_WEAK)
1453     strcat (buffer, " weak");
1454
1455   if (flags & BSF_SECTION_SYM)
1456     strcat (buffer, " section-sym");
1457
1458   if (flags & BSF_OLD_COMMON)
1459     strcat (buffer, " old-common");
1460
1461   if (flags & BSF_NOT_AT_END)
1462     strcat (buffer, " not-at-end");
1463
1464   if (flags & BSF_CONSTRUCTOR)
1465     strcat (buffer, " constructor");
1466
1467   if (flags & BSF_WARNING)
1468     strcat (buffer, " warning");
1469
1470   if (flags & BSF_INDIRECT)
1471     strcat (buffer, " indirect");
1472
1473   if (flags & BSF_FILE)
1474     strcat (buffer, " file");
1475
1476   if (flags & DYNAMIC)
1477     strcat (buffer, " dynamic");
1478
1479   if (flags & ~(BSF_LOCAL
1480                 | BSF_GLOBAL
1481                 | BSF_DEBUGGING
1482                 | BSF_FUNCTION
1483                 | BSF_KEEP
1484                 | BSF_KEEP_G
1485                 | BSF_WEAK
1486                 | BSF_SECTION_SYM
1487                 | BSF_OLD_COMMON
1488                 | BSF_NOT_AT_END
1489                 | BSF_CONSTRUCTOR
1490                 | BSF_WARNING
1491                 | BSF_INDIRECT
1492                 | BSF_FILE
1493                 | BSF_DYNAMIC))
1494     strcat (buffer, " unknown-bits");
1495
1496   return buffer;
1497 }
1498 #endif
1499 \f
1500 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
1501    reconstruct an ELF file by reading the segments out of remote memory
1502    based on the ELF file header at EHDR_VMA and the ELF program headers it
1503    points to.  If not null, *LOADBASEP is filled in with the difference
1504    between the VMAs from which the segments were read, and the VMAs the
1505    file headers (and hence BFD's idea of each section's VMA) put them at.
1506
1507    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1508    remote memory at target address VMA into the local buffer at MYADDR; it
1509    should return zero on success or an `errno' code on failure.  TEMPL must
1510    be a BFD for a target with the word size and byte order found in the
1511    remote memory.  */
1512
1513 bfd *
1514 NAME(_bfd_elf,bfd_from_remote_memory)
1515   (bfd *templ,
1516    bfd_vma ehdr_vma,
1517    bfd_vma *loadbasep,
1518    int (*target_read_memory) (bfd_vma, char *, int))
1519 {
1520   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
1521   Elf_Internal_Ehdr i_ehdr;     /* Elf file header, internal form */
1522   Elf_External_Phdr *x_phdrs;
1523   Elf_Internal_Phdr *i_phdrs, *last_phdr;
1524   bfd *nbfd;
1525   struct bfd_in_memory *bim;
1526   int contents_size;
1527   char *contents;
1528   int err;
1529   unsigned int i;
1530   bfd_vma loadbase;
1531
1532   /* Read in the ELF header in external format.  */
1533   err = target_read_memory (ehdr_vma, (char *) &x_ehdr, sizeof x_ehdr);
1534   if (err)
1535     {
1536       bfd_set_error (bfd_error_system_call);
1537       errno = err;
1538       return NULL;
1539     }
1540
1541   /* Now check to see if we have a valid ELF file, and one that BFD can
1542      make use of.  The magic number must match, the address size ('class')
1543      and byte-swapping must match our XVEC entry.  */
1544
1545   if (! elf_file_p (&x_ehdr)
1546       || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1547       || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1548     {
1549       bfd_set_error (bfd_error_wrong_format);
1550       return NULL;
1551     }
1552
1553   /* Check that file's byte order matches xvec's */
1554   switch (x_ehdr.e_ident[EI_DATA])
1555     {
1556     case ELFDATA2MSB:           /* Big-endian */
1557       if (! bfd_header_big_endian (templ))
1558         {
1559           bfd_set_error (bfd_error_wrong_format);
1560           return NULL;
1561         }
1562       break;
1563     case ELFDATA2LSB:           /* Little-endian */
1564       if (! bfd_header_little_endian (templ))
1565         {
1566           bfd_set_error (bfd_error_wrong_format);
1567           return NULL;
1568         }
1569       break;
1570     case ELFDATANONE:           /* No data encoding specified */
1571     default:                    /* Unknown data encoding specified */
1572       bfd_set_error (bfd_error_wrong_format);
1573       return NULL;
1574     }
1575
1576   elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1577
1578   /* The file header tells where to find the program headers.
1579      These are what we use to actually choose what to read.  */
1580
1581   if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1582     {
1583       bfd_set_error (bfd_error_wrong_format);
1584       return NULL;
1585     }
1586
1587   x_phdrs = bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1588   if (x_phdrs == NULL)
1589     {
1590       bfd_set_error (bfd_error_no_memory);
1591       return NULL;
1592     }
1593   err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (char *) x_phdrs,
1594                             i_ehdr.e_phnum * sizeof x_phdrs[0]);
1595   if (err)
1596     {
1597       free (x_phdrs);
1598       bfd_set_error (bfd_error_system_call);
1599       errno = err;
1600       return NULL;
1601     }
1602   i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1603
1604   contents_size = 0;
1605   last_phdr = NULL;
1606   loadbase = ehdr_vma;
1607   for (i = 0; i < i_ehdr.e_phnum; ++i)
1608     {
1609       elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1610       if (i_phdrs[i].p_type == PT_LOAD)
1611         {
1612           bfd_vma segment_end;
1613           segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1614                          + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1615           if (segment_end > (bfd_vma) contents_size)
1616             contents_size = segment_end;
1617
1618           if ((i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1619             loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1620
1621           last_phdr = &i_phdrs[i];
1622         }
1623     }
1624   if (last_phdr == NULL)
1625     {
1626       /* There were no PT_LOAD segments, so we don't have anything to read.  */
1627       free (x_phdrs);
1628       bfd_set_error (bfd_error_wrong_format);
1629       return NULL;
1630     }
1631
1632   /* Trim the last segment so we don't bother with zeros in the last page
1633      that are off the end of the file.  However, if the extra bit in that
1634      page includes the section headers, keep them.  */
1635   if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1636       && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1637                                      + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1638     {
1639       contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1640       if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1641                                      + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1642         contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1643     }
1644   else
1645     contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1646
1647   /* Now we know the size of the whole image we want read in.  */
1648   contents = bfd_zmalloc (contents_size);
1649   if (contents == NULL)
1650     {
1651       free (x_phdrs);
1652       bfd_set_error (bfd_error_no_memory);
1653       return NULL;
1654     }
1655
1656   for (i = 0; i < i_ehdr.e_phnum; ++i)
1657     if (i_phdrs[i].p_type == PT_LOAD)
1658       {
1659         bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1660         bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1661                        + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1662         if (end > (bfd_vma) contents_size)
1663           end = contents_size;
1664         err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1665                                   & -i_phdrs[i].p_align,
1666                                   contents + start, end - start);
1667         if (err)
1668           {
1669             free (x_phdrs);
1670             free (contents);
1671             bfd_set_error (bfd_error_system_call);
1672             errno = err;
1673             return NULL;
1674           }
1675       }
1676   free (x_phdrs);
1677
1678   /* If the segments visible in memory didn't include the section headers,
1679      then clear them from the file header.  */
1680   if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1681                                  + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1682     {
1683       memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1684       memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1685       memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1686     }
1687
1688   /* This will normally have been in the first PT_LOAD segment.  But it
1689      conceivably could be missing, and we might have just changed it.  */
1690   memcpy (contents, &x_ehdr, sizeof x_ehdr);
1691
1692   /* Now we have a memory image of the ELF file contents.  Make a BFD.  */
1693   bim = bfd_malloc (sizeof (struct bfd_in_memory));
1694   if (bim == NULL)
1695     {
1696       free (contents);
1697       bfd_set_error (bfd_error_no_memory);
1698       return NULL;
1699     }
1700   nbfd = _bfd_new_bfd ();
1701   if (nbfd == NULL)
1702     {
1703       free (bim);
1704       free (contents);
1705       bfd_set_error (bfd_error_no_memory);
1706       return NULL;
1707     }
1708   nbfd->filename = "<in-memory>";
1709   nbfd->xvec = templ->xvec;
1710   bim->size = contents_size;
1711   bim->buffer = contents;
1712   nbfd->iostream = bim;
1713   nbfd->flags = BFD_IN_MEMORY;
1714   nbfd->direction = read_direction;
1715   nbfd->mtime = time (NULL);
1716   nbfd->mtime_set = TRUE;
1717
1718   if (loadbasep)
1719     *loadbasep = loadbase;
1720   return nbfd;
1721 }
1722 \f
1723 #include "elfcore.h"
1724 \f
1725 /* Size-dependent data and functions.  */
1726 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1727   sizeof (Elf_External_Ehdr),
1728   sizeof (Elf_External_Phdr),
1729   sizeof (Elf_External_Shdr),
1730   sizeof (Elf_External_Rel),
1731   sizeof (Elf_External_Rela),
1732   sizeof (Elf_External_Sym),
1733   sizeof (Elf_External_Dyn),
1734   sizeof (Elf_External_Note),
1735   4,
1736   1,
1737   ARCH_SIZE, LOG_FILE_ALIGN,
1738   ELFCLASS, EV_CURRENT,
1739   elf_write_out_phdrs,
1740   elf_write_shdrs_and_ehdr,
1741   elf_write_relocs,
1742   elf_swap_symbol_in,
1743   elf_swap_symbol_out,
1744   elf_slurp_reloc_table,
1745   elf_slurp_symbol_table,
1746   elf_swap_dyn_in,
1747   elf_swap_dyn_out,
1748   elf_swap_reloc_in,
1749   elf_swap_reloc_out,
1750   elf_swap_reloca_in,
1751   elf_swap_reloca_out
1752 };