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