contrib/binutils-2.15/bfd/elfcode.h

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