contrib/binutils-2.24/bfd/elfcode.h

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